#!/bin/sh

# simple intermediate test tool to validate parser

PROG=$PWD/econs
if [ ! -f $PROG ]; then
    echo "$0 must be run from top directory"
    exit 1
fi
# compile as
# make CFLAGS="-O0 -g3 -DCACHE_DEBUG=1 -DGC_CHECK=1"
# to also garbage collect and check the cache at every memory allocation
PROG="valgrind -q $PROG"

function test {
    I=$1
    E=$2
    R=`echo "$I" | $PROG`
    if [ "$E" != "$R" ]; then
	echo '>>>'
	echo "$E"
	echo '---'
	echo "$R"
	echo '<<<'
    fi
}

test "" ""

test '-5;!0;~1;4&&5;4||0;1!=2;1<4;2<=1;-1==1;1>=2;5>1;3&2;2|1;3^2;1+1;2-1;2*5;6/8;5\2;7%3;5<<2;3>>2;1<<<3;-4>>>3;' "
void () {
    -5;
    1;
    -2;
    1;
    1;
    1;
    1;
    0;
    0;
    0;
    1;
    2;
    3;
    1;
    2;
    1;
    10;
    3/4;
    2;
    1;
    20;
    3/4;
    8;
    -1;
}"

test '-5.;!-1.0;.5&&4e2;1e-2||0.0;0.0!=1e-6;2.5<3.2;3.2<=3.2;0.0==1.4;1e2>=1e-2;1.>.9;0.25+0.75;1.0-1.5;2.0*0.5;1.0/2.0;2.3\2;-2.5%2.0;3.5<<3;4.5>>2;-3.5<<<3;4.0>>>1;' "
void () {
    -5.0;
    0;
    1;
    1;
    1;
    1;
    1;
    0;
    1;
    1;
    1.0;
    -0.5;
    1.0;
    0.5;
    1;
    -0.5;
    28.0;
    1.125;
    -32;
    2;
}"

test '1/-3;!-3/4;1/2&&0/3;1/2||1/3;1/2!=2/4;1/2<3/2;4/3<=4/5;3/7==7/3;1/2>=1/-2;-4/3>4/5;3/2+2/3;-5/4-4/3;1/2*4/3;2/-6/4/5;14/5\2;-14/5%2;3/7<<3;3/7>>3;7/-3<<<4;7/-3>>>1;' "
void () {
    -1/3;
    0;
    0;
    1;
    0;
    1;
    0;
    0;
    1;
    0;
    13/6;
    -31/12;
    2/3;
    -1/60;
    1;
    -2/5;
    24/7;
    3/56;
    -48;
    -2;
}"

test '-0x7ffffffffffffffff;!0x7ffffffffffffffff;0x7ffffffffffffffff&&0x8000000000000;0x7ffffffffffffffff||0x8000000000000;0x7ffffffffffffffff!=-0x8000000000000;0x7ffffffffffffffff<-0x8000000000000;-0x7ffffffffffffffff<=0x8000000000000;0x7ffffffffffffffff==0x7ffffffffffffffff;0x8000000000000>=0x8000000000001;0x8000000000001>0x8000000000000;0x7ffffff00000000&0x7ff00000fffff000000;0x7ffffff00000000|0x7ff00000fffff000000;0x7ffffff00000000^0x7ff00000fffff000000;0x7ffffff00000000+0x7ff00000fffff000000;0x7ffffff00000000-0x7ff00000fffff000000;0x7ffffff00000000*0x7ff00000fffff000000;0x7ffffff00000000/0x7ff00000fffff000000;0x7ff00000fffff000000\0x7ffffff00000000;0x7ff00000fffff000000%0x7ffffff00000000;0x7ffffff00000000<<5;0x7ffffff00000000>>128;0x7ffffff00000000<<<1;0x7ffffff00000000>>>4;' "
void () {
    -147573952589676412927;
    0;
    1;
    1;
    1;
    0;
    1;
    1;
    0;
    1;
    17587891077120;
    37761061579635738804224;
    37761061562047847727104;
    37761061597223629881344;
    -37759908675727612968960;
    21767437506934928722835131991786398941184;
    34359738112/2250700303106047;
    65504;
    298929707024384;
    18446743936270598144;
    134217727/79228162514264337593543950336;
    1152921496016912384;
    36028796750528512;
}"

test '-0x7ffffff00000000/3;!0x7ffffff00000000/3;0x7ffffff00000000/3&&-0x7ffffff00000000/7;0x7ffffff00000000/3||-0x7ffffff00000000/7;0x7ffffff00000000/3!=-0x7ffffff00000000/7;0x7ffffff00000000/3<-0x7ffffff00000000/7;0x7ffffff00000000/3<=-0x7ffffff00000000/7;0x7ffffff00000000/3==-0x7ffffff00000000/7;0x7ffffff00000000/3>=-0x7ffffff00000000/7;0x7ffffff00000000/3>-0x7ffffff00000000/7;0x7ffffff00000000/3+ -0x7ffffff00000000/7;0x7ffffff00000000/3- -0x7ffffff00000000/7;0x7ffffff00000000/3*-0x7ffffff00000000/7;0x7ffffff00000000/3/-0x7ffffff00000000/7;-0x7ffffff00000000/7<<7;-0x7ffffff00000000/7>>1;-0x7ffffff00000000/7<<<7;-3/0x7ffffff00000000>>11;' "
void () {
    -576460748008456192/3;
    0;
    1;
    1;
    1;
    0;
    0;
    0;
    1;
    1;
    329406141719117824/3;
    823515354297794560/3;
    -47472427713495547075882105597591552/3;
    -1/21;
    -10540996535011770368;
    -41175767714889728;
    -10540996535011770368;
    -3/1180591611921318281216;
}"

test '-5L;!-1.0L;.5L&&4e2L;1e-2L||0L;0L!=1e-6L;2.5L<3.2L;3.2L<=3.2L;0L==1.4L;1e2L>=1e-2L;1L>.9L;0.25L+0.75L;1L-1.5L;2L*0.5L;1L/2L;2.3L\2L;-2.5L%2L;3.5L<<3;4.5L>>2;-3.5L<<<3;4.0L>>>1;' "
void () {
    -5.0l;
    0;
    1;
    1;
    1;
    1;
    1;
    0;
    1;
    1;
    1.0l;
    -0.5l;
    1.0l;
    0.5l;
    1;
    -0.5l;
    28.0l;
    1.125l;
    -32;
    2;
}"

test "-complex(1,1);!complex(1,1.0);complex(1,1/2)&&complex(1,0x80000000000000000000000);complex(1,0x777777777777777777777777777777/3)||complex(1,1L);complex(0,1)!=complex(0L,1/2);complex(0,0.5)==complex(0,1/2);complex(1,1)+complex(2,2);complex(1/2,1)-complex(2,1/2);complex(1,0.5)*complex(2,1);complex(1,0.5)/complex(2,-2L);complex(1,0.5)<<3;complex(1,1/2)>>12;" "
void () {
    (-1-I);
    0;
    1;
    1;
    1;
    1;
    (3+3*I);
    (-3/2+1/2*I);
    (1.5+2.0*I);
    (0.125l+0.375l*I);
    (8.0+4.0*I);
    (1/4096+1/8192*I);
}"

########################################################################
test "1+2.0;2+1/2;-1+0x800000000000000000000;-1+0x800000000000000000000/3;-1+1e6L;" "
void () {
    3.0;
    5/2;
    9671406556917033397649407;
    9671406556917033397649405/3;
    999999.0l;
}"

test "1.0+2;2.0+1/2;-1.0+0x800000000000000000001;-1.0+0x800000000000000000000/3;-1.0+1e6L;" "
void () {
    3.0;
    2.5;
    9671406556917033400000000.0;
    3223802185639011000000000.0;
    999999.0l;
}"

test "1/2+1;1/2+2.0;-1/2+0x800000000000000000000;-1/2+0x800000000000000000000/3;-1/2+1e6L;" "
void () {
    3/2;
    2.5;
    19342813113834066795298815/2;
    19342813113834066795298813/6;
    999999.5l;
}"

test "0x800000000000000000000+1;0x800000000000000000000+2.0;0x800000000000000000000+1/2;-0x800000000000000000000+0x800000000000000000000/3;-0x800000000000000000000+1e6L;" "
void () {
    9671406556917033397649409;
    9671406556917033400000000.0;
    19342813113834066795298817/2;
    -19342813113834066795298816/3;
    -9671406556917033400000000.0l;
}"

test "0x800000000000000000000/3+1;0x800000000000000000000/3+2.0;0x800000000000000000000/3+1/2;0x800000000000000000000/3+0x800000000000000000000;-0x800000000000000000000/3+1e6L;" "
void () {
    9671406556917033397649411/3;
    3223802185639011000000000.0;
    19342813113834066795298819/6;
    38685626227668133590597632/3;
    -3223802185639011000000000.0l;
}"

test "1L+2;2L+0.5;3L+1/2;-1L+0x800000000000000000001;-1L+0x800000000000000000000/3;" "
void () {
    3.0l;
    2.5l;
    3.5l;
    9671406556917033400000000.0l;
    3223802185639011000000000.0l;
}"

########################################################################
test "if(1);else;if(1,2,3);else;if(0);else;if(2,1,0);else;" "
void () {
    ;
    1, 2;
    ;
    2, 1;
}"

test "if(1){;}else{;}if(1,2,3){;}else{;}if(0){;}else{;}if(2,1,0){-1;}else{-2;}" "
void () {
    {
	;
    }
    1, 2, {
	;
    };
    {
	;
    }
    2, 1, {
	-2;
    };
}"

test "1?2:3;3?4:5;0?1:2;0?-1:-2;" "
void () {
    2;
    4;
    2;
    -2;
}"

test "for(1;0;3);for(;0;3);for(;0;3){;}for(1,2,3;0;){}for(1;2;3);for(1,2;3,4;5,6){;}" "
void () {
    1;
    ;
    ;
    1, 2, 3;
    for (1; 2; 3)
	;
    for (1, 2; 3, 4; 5, 6) {
	;
    }
}"

test "do;while(2);do{;}while(3,4);do{;}while(0);do;while(1,0);" "
void () {
    do
	;
    while (2);
    do {
	;
    } while (3, 4);
    {
	;
    }
    ;
}"

test "while(1);while(0);while(1,0){;}while(-2-3);" "
void () {
    while (1)
	;
    ;
    1;
    while (-5)
	;
}"

test "auto a,b;class s{d;};s c;auto v[][][];auto w[];(1);(1,2,3);+2.5;v[1+2];v[2][3][4];v[w[2]];c.d;a++;++a;a--;--a;a(1+2,3/2);sizeof(int32_t);a={1,2,3};void min(a,b){return a<= b?a:b;}" "
void () {
    auto a, b;
    class s {
	auto d;
    };
    s c;
    auto v[0][0][0];
    auto w[0];
    1;
    (1, 2, 3);
    2.5;
    v[3];
    v[2][3][4];
    v[w[2]];
    c.d;
    a++;
    ++a;
    a--;
    --a;
    a(3, 3/2);
    0;
    a = {
	1, 2, 3
    };
    void min(auto a, auto b) {
	return a <= b ? a : b;
    }
}"

test "class a{int8_t i8;uint8_t u8;int16_t i16;uint16_t u16;int32_t i32;uint32_t u32;int64_t i64;uint64_t u64;o;int8_t vi8[];uint8_t vu8[];int16_t vi16[];uint16_t vu16[];int32_t vi32[];uint32_t vu32[];int64_t vi64[];uint64_t vu64[];vo[];};" "
void () {
    class a {
	int8_t i8;
	uint8_t u8;
	int16_t i16;
	uint16_t u16;
	int32_t i32;
	uint32_t u32;
	int64_t i64;
	uint64_t u64;
	auto o;
	int8_t vi8[0];
	uint8_t vu8[0];
	int16_t vi16[0];
	uint16_t vu16[0];
	int32_t vi32[0];
	uint32_t vu32[0];
	int64_t vi64[0];
	uint64_t vu64[0];
	auto vo[0];
    };
}"

test "class a{int8_t vi8[1];uint8_t vu8[2];int16_t vi16[3];uint16_t vu16[4];int32_t vi32[5];uint32_t vu32[6];int64_t vi64[7];uint64_t vu64[8];vo[9];};" "
void () {
    class a {
	int8_t vi8[1];
	uint8_t vu8[2];
	int16_t vi16[3];
	uint16_t vu16[4];
	int32_t vi32[5];
	uint32_t vu32[6];
	int64_t vi64[7];
	uint64_t vu64[8];
	auto vo[9];
    };
}"


########################################################################
PROG="$PROG -v"
test "void t(d){auto a,b,c;for(a=b=0;a<d;++a)b+=a;d=b;}" "
void () {
    void t(auto d#0) {
	auto a#0, b#0, c#0;
	for (a#1 = b#1 = 0; a#2 < d#0; ++a#3)
	    b#3 = b#2 + a#2;
	d#1 = b#4;
    }
}"

test "void t(d,e){auto a,b,c;for(a=c=0;a<d;++a)for(b=a;b<e;++b){d=1;c+=a+b;}d=c;}" "
void () {
    void t(auto d#0, auto e#0) {
	auto a#0, b#0, c#0;
	for (a#1 = c#1 = 0; a#2 < d#0; ++a#3)
	    for (b#1 = a#2; b#2 < e#0; ++b#3) {
		d#1 = 1;
		c#3 = c#2 + (a#2 + b#2);
	    }
	d#2 = c#4;
    }
}"

test "void t(){auto i=0,j=0,k;L0:++i;if(i&1){goto L1;j=i;}L1:++i;if(i<10)goto L0;k=j;}" "
void () {
    void t() {
	auto i#0 = 0, j#0 = 0, k#0;
    L0:
	++i#1;
	if (i#1 & 1) {
	    goto L1;
	    j#1 = i#1;
	}
    L1:
	++i#2;
	if (i#2 < 10)
	    goto L0;
	k#1 = j#2;
    }
}"

test "void t(d){auto a,b,c;for(a=b=0;a<d;++a){if(a&1)continue;b+=a;if(b&1)break;c=d;}d=c;}" "
void () {
    void t(auto d#0) {
	auto a#0, b#0, c#0;
	for (a#1 = b#1 = 0; a#2 < d#0; ++a#4) {
	    if (a#2 & 1)
		continue;
	    b#3 = b#2 + a#3;
	    if (b#3 & 1)
		break;
	    c#1 = d#0;
	}
	d#1 = c#2;
    }
}"

test "void t(a,b,c){auto d;switch(a){case 1:d=a;c=b;break;case 2:d=b;case 3:d=c;break;default:d=0;break;}d+=a+b+c;}" "
void () {
    void t(auto a#0, auto b#0, auto c#0) {
	auto d#0;
	switch (a#0) {
	case 1:
	    d#1 = a#0;
	    c#1 = b#0;
	    break;
	case 2:
	    d#2 = b#0;
	case 3:
	    d#3 = c#2;
	    break;
	default:
	    d#4 = 0;
	    break;
	}
	d#6 = d#5 + (a#0 + b#0 + c#3);
    }
}"

test "void t() {auto a,b,c;c=(a=1)+(b=2);c=(a=1,2)+(b=3,4+5);c=a+b-c;}
" "
void () {
    void t() {
	auto a#0, b#0, c#0;
	c#1 = (a#1 = 1) + (b#1 = 2);
	c#2 = (a#2 = 1, 2) + (b#2 = 3, 9);
	c#3 = 4 - c#2;
    }
}"

test "void t(d){auto a,b,c;for(a=b=0;a<d;c=a++)b+=a+c;d=b+a-c;}" "
void () {
    void t(auto d#0) {
	auto a#0, b#0, c#0;
	for (a#1 = b#1 = 0; a#2 < d#0; c#2 = a#2++)
	    b#3 = b#2 + (a#2 + c#1);
	d#1 = b#4 + a#3 - c#3;
    }
}"

test "void t(){auto a=1,b=2,c,d,i,j,k;c=a+b;for(i=0;i<10;++i){c=a+b;d=c-b;for(j=0;j<10;++j){c=a+b;d=c-b;for(k=0;k<10;++k){c=a+b;d=c-b;}}}}" "
void () {
    void t() {
	auto a#0 = 1, b#0 = 2, c#0, d#0, i#0, j#0, k#0;
	c#1 = 3;
	for (i#1 = 0; i#2 < 10; ++i#3) {
	    c#2 = 3;
	    d#1 = 1;
	    for (j#1 = 0; j#2 < 10; ++j#3) {
		c#3 = 3;
		d#2 = 1;
		for (k#1 = 0; k#2 < 10; ++k#3) {
		    c#4 = 3;
		    d#3 = 1;
		}
	    }
	}
    }
}"

test "auto t(a[],i){auto j=a[0],v=a[i];return j=v?a[v+j]:a[i-j];}
" "
void () {
    auto t(auto a#0[0]#0, auto i#0) {
	auto j#0 = a#0[0]#0, v#0 = a#0[i#0]#0;
	return j#1 = v#0 ? a#0[v#0 + j#0]#0 : a#0[i#0 - j#0]#0;
    }
}"

test "class s_t{a,b,c;};void t(s_t s,s_t t,a,b,c){s.a+=a;s.b=s.c+b;s.c=s.a-s.b-s.c+c;s=t;s.c+=s.a=s.b/2;}" "
void () {
    class s_t {
	auto a;
	auto b;
	auto c;
    };
    void t(s_t s#0, s_t t#0, auto a#0, auto b#0, auto c#0) {
	s#0.a#1 += a#0;
	s#0.b#1 = s#0.c#0 + b#0;
	s#0.c#1 = s#0.a#1 - s#0.b#1 - s#0.c#0 + c#0;
	s#1 = t#0;
	s#1.c#2 += s#1.a#2 = s#1.b#1 / 2;
    }
}"

test "class s_t{a,b,c;};void t(s_t s,v[],a){s.a=v[0]+a;v[1]=s.b=a++;v[s.c]=a-s.c;}" "
void () {
    class s_t {
	auto a;
	auto b;
	auto c;
    };
    void t(s_t s#0, auto v#0[0]#0, auto a#0) {
	s#0.a#1 = v#0[0]#0 + a#0;
	v#0[1]#1 = s#0.b#1 = a#0++;
	v#0[s#0.c#0]#1 = a#1 - s#0.c#0;
    }
}"

test "auto v;void t(a,b){auto c=v;int32_t vi[];int32_t i;vi[0]=3;f(a,b);i=v;f(c,i);f(v,c);f(i,vi[i]);}" "
void () {
    auto v#0;
    void t(auto a#0, auto b#0) {
	auto c#0 = v#0;
	int32_t vi#0[0]#0;
	int32_t i#0;
	vi#0[0]#1 = 3;
	f(a#0, b#0);
	i#1 = v#1;
	f(c#0, i#1);
	f(v#2, c#0);
	f(i#1, vi#1[i#1]#0);
    }
}"

test "class s_t;class s_t {s_t s;auto a;};void t(s_t s){s.s.s.s=1;}" "
void () {
    class s_t;
    class s_t {
	s_t s;
	auto a;
    };
    void t(s_t s#0) {
	s#0.s#0.s#0.s#1 = 1;
    }
}"

test "class a_t,b_t;class a_t{b_t b;};class b_t{a_t a;};void f(a_t a, b_t b){a.b=b;b.a=a;a.b.a.b=b;b.a.b.a=a;}" "
void () {
    class a_t, b_t;
    class a_t {
	b_t b;
    };
    class b_t {
	a_t a;
    };
    void f(a_t a#0, b_t b#0) {
	a#0.b#1 = b#0;
	b#0.a#1 = a#0;
	a#0.b#1.a#1.b#2 = b#0;
	b#0.a#1.b#2.a#2 = a#0;
    }
}"

test "void t(a){auto vvv[1][2][3];vvv[0][1][2]=a;}" "
void () {
    void t(auto a#0) {
	auto vvv#0[1]#0[2]#0[3]#0;
	vvv#0[0]#0[1]#0[2]#1 = a#0;
    }
}"

test "class a_t{a_t v[];};void t(a_t a,a_t b,c){a_t v[];v[0]=a;a.v[1]=a;v[c]=b;b.v[c]=a;}" "
void () {
    class a_t {
	a_t v[0];
    };
    void t(a_t a#0, a_t b#0, auto c#0) {
	a_t v#0[0]#0;
	v#0[0]#1 = a#0;
	a#0.v#0[1]#1 = a#0;
	v#0[c#0]#1 = b#0;
	b#0.v#0[c#0]#2 = a#0;
    }
}"

########################################################################
PROG="${PROG}2"
test "void f(int8_t c, uint8_t uc, int16_t s, uint16_t us,
       int32_t i, uint32_t ui, int64_t l, uint64_t ul,
       float32_t f, float64_t d, auto v)
{
int8_t x;+x;-x;~x;
x&c;x|c;x^c;x<<c;x>>c;x<<<c;x>>>c;x+c;x-c;x*c;x\\c;x/c;x%c;
x&uc;x|uc;x^uc;x<<uc;x>>uc;x<<<uc;x>>>uc;x+uc;x-uc;x*uc;x\\uc;x/uc;x%uc;
x&s;x|s;x^s;x<<s;x>>s;x<<<s;x>>>s;x+s;x-s;x*s;x\\s;x/s;x%s;
x&us;x|us;x^us;x<<us;x>>us;x<<<us;x>>>us;x+us;x-us;x*us;x\\us;x/us;x%us;
x&i;x|i;x^i;x<<i;x>>i;x<<<i;x>>>i;x+i;x-i;x*i;x\\i;x/i;x%i;
x&ui;x|ui;x^ui;x<<ui;x>>ui;x<<<ui;x>>>ui;x+ui;x-ui;x*ui;x\\ui;x/ui;x%ui;
x&l;x|l;x^l;x<<l;x>>l;x<<<l;x>>>l;x+l;x-l;x*l;x\\l;x/l;x%l;
x&ul;x|ul;x^ul;x<<ul;x>>ul;x<<<ul;x>>>ul;x+ul;x-ul;x*ul;x\\ul;x/ul;x%ul;
x&f;x|f;x^f;x<<f;x>>f;x<<<f;x>>>f;x+f;x-f;x*f;x\\f;x/f;x%f;
x&d;x|d;x^d;x<<d;x>>d;x<<<d;x>>>d;x+d;x-d;x*d;x\\d;x/d;x%d;
x&v;x|v;x^v;x<<v;x>>v;x<<<v;x>>>v;x+v;x-v;x*v;x\\v;x/v;x%v;
x+(1/2);x-(1/2);x*(1/2);x\\(1/2);x/(1/2);x%(1/2);
x<<1L;x>>1L;x<<<1L;x>>>1L;x+1L;x-1L;x*1L;x\\1L;x/1L;x%1L;
}" "
void () {
    void f(int8_t c#0, uint8_t uc#0, int16_t s#0, uint16_t us#0, int32_t i#0, uint32_t ui#0, int64_t l#0, uint64_t ul#0, float32_t f#0, float64_t d#0, auto v#0) {
	int8_t x#0;
	<half>+x#0</half>;
	<word>-x#0</word>;
	<half>~x#0</half>;
	<half>x#0 & c#0</half>;
	<half>x#0 | c#0</half>;
	<half>x#0 ^ c#0</half>;
	<integer>x#0 << c#0</integer>;
	<exact>x#0 >> c#0</exact>;
	<integer>x#0 <<< c#0</integer>;
	<half>x#0 >>> c#0</half>;
	<word>x#0 + c#0</word>;
	<word>x#0 - c#0</word>;
	<word>x#0 * c#0</word>;
	<half>x#0 \ c#0</half>;
	<exact>x#0 / c#0</exact>;
	<half>x#0 % c#0</half>;
	<half>x#0 & uc#0</half>;
	<half>x#0 | uc#0</half>;
	<half>x#0 ^ uc#0</half>;
	<integer>x#0 << uc#0</integer>;
	<exact>x#0 >> uc#0</exact>;
	<integer>x#0 <<< uc#0</integer>;
	<half>x#0 >>> uc#0</half>;
	<word>x#0 + uc#0</word>;
	<word>x#0 - uc#0</word>;
	<word>x#0 * uc#0</word>;
	<half>x#0 \ uc#0</half>;
	<exact>x#0 / uc#0</exact>;
	<half>x#0 % uc#0</half>;
	<half>x#0 & s#0</half>;
	<half>x#0 | s#0</half>;
	<half>x#0 ^ s#0</half>;
	<integer>x#0 << s#0</integer>;
	<exact>x#0 >> s#0</exact>;
	<integer>x#0 <<< s#0</integer>;
	<half>x#0 >>> s#0</half>;
	<word>x#0 + s#0</word>;
	<word>x#0 - s#0</word>;
	<word>x#0 * s#0</word>;
	<half>x#0 \ s#0</half>;
	<exact>x#0 / s#0</exact>;
	<half>x#0 % s#0</half>;
	<half>x#0 & us#0</half>;
	<half>x#0 | us#0</half>;
	<half>x#0 ^ us#0</half>;
	<integer>x#0 << us#0</integer>;
	<exact>x#0 >> us#0</exact>;
	<integer>x#0 <<< us#0</integer>;
	<half>x#0 >>> us#0</half>;
	<word>x#0 + us#0</word>;
	<word>x#0 - us#0</word>;
	<word>x#0 * us#0</word>;
	<half>x#0 \ us#0</half>;
	<exact>x#0 / us#0</exact>;
	<half>x#0 % us#0</half>;
	<half>x#0 & i#0</half>;
	<half>x#0 | i#0</half>;
	<half>x#0 ^ i#0</half>;
	<integer>x#0 << i#0</integer>;
	<exact>x#0 >> i#0</exact>;
	<integer>x#0 <<< i#0</integer>;
	<half>x#0 >>> i#0</half>;
	<word>x#0 + i#0</word>;
	<word>x#0 - i#0</word>;
	<word>x#0 * i#0</word>;
	<half>x#0 \ i#0</half>;
	<exact>x#0 / i#0</exact>;
	<half>x#0 % i#0</half>;
	<half>x#0 & ui#0</half>;
	<word>x#0 | ui#0</word>;
	<word>x#0 ^ ui#0</word>;
	<integer>x#0 << ui#0</integer>;
	<exact>x#0 >> ui#0</exact>;
	<integer>x#0 <<< ui#0</integer>;
	<half>x#0 >>> ui#0</half>;
	<integer>x#0 + ui#0</integer>;
	<integer>x#0 - ui#0</integer>;
	<integer>x#0 * ui#0</integer>;
	<word>x#0 \ ui#0</word>;
	<exact>x#0 / ui#0</exact>;
	<word>x#0 % ui#0</word>;
	<half>x#0 & l#0</half>;
	<word>x#0 | l#0</word>;
	<word>x#0 ^ l#0</word>;
	<integer>x#0 << l#0</integer>;
	<exact>x#0 >> l#0</exact>;
	<integer>x#0 <<< l#0</integer>;
	<half>x#0 >>> l#0</half>;
	<integer>x#0 + l#0</integer>;
	<integer>x#0 - l#0</integer>;
	<integer>x#0 * l#0</integer>;
	<word>x#0 \ l#0</word>;
	<exact>x#0 / l#0</exact>;
	<word>x#0 % l#0</word>;
	<half>x#0 & ul#0</half>;
	<integer>x#0 | ul#0</integer>;
	<integer>x#0 ^ ul#0</integer>;
	<integer>x#0 << ul#0</integer>;
	<exact>x#0 >> ul#0</exact>;
	<integer>x#0 <<< ul#0</integer>;
	<half>x#0 >>> ul#0</half>;
	<integer>x#0 + ul#0</integer>;
	<integer>x#0 - ul#0</integer>;
	<integer>x#0 * ul#0</integer>;
	<integer>x#0 \ ul#0</integer>;
	<exact>x#0 / ul#0</exact>;
	<integer>x#0 % ul#0</integer>;
	<half>x#0 & f#0</half>;
	<integer>x#0 | f#0</integer>;
	<integer>x#0 ^ f#0</integer>;
	<integer>x#0 << f#0</integer>;
	<exact>x#0 >> f#0</exact>;
	<integer>x#0 <<< f#0</integer>;
	<half>x#0 >>> f#0</half>;
	<single>x#0 + f#0</single>;
	<single>x#0 - f#0</single>;
	<single>x#0 * f#0</single>;
	<integer>x#0 \ f#0</integer>;
	<single>x#0 / f#0</single>;
	<single>x#0 % f#0</single>;
	<half>x#0 & d#0</half>;
	<integer>x#0 | d#0</integer>;
	<integer>x#0 ^ d#0</integer>;
	<integer>x#0 << d#0</integer>;
	<exact>x#0 >> d#0</exact>;
	<integer>x#0 <<< d#0</integer>;
	<half>x#0 >>> d#0</half>;
	<float>x#0 + d#0</float>;
	<float>x#0 - d#0</float>;
	<float>x#0 * d#0</float>;
	<integer>x#0 \ d#0</integer>;
	<float>x#0 / d#0</float>;
	<float>x#0 % d#0</float>;
	<half>x#0 & v#0</half>;
	<integer>x#0 | v#0</integer>;
	<integer>x#0 ^ v#0</integer>;
	<undef>x#0 << v#0</undef>;
	<undef>x#0 >> v#0</undef>;
	<integer>x#0 <<< v#0</integer>;
	<half>x#0 >>> v#0</half>;
	<undef>x#0 + v#0</undef>;
	<undef>x#0 - v#0</undef>;
	<undef>x#0 * v#0</undef>;
	<integer>x#0 \ v#0</integer>;
	<undef>x#0 / v#0</undef>;
	<real>x#0 % v#0</real>;
	<exact>x#0 + 1/2</exact>;
	<exact>x#0 - 1/2</exact>;
	<exact>x#0 * 1/2</exact>;
	<integer>x#0 \ 1/2</integer>;
	<exact>x#0 / 1/2</exact>;
	<exact>x#0 % 1/2</exact>;
	<integer>x#0 << 1.0l</integer>;
	<exact>x#0 >> 1.0l</exact>;
	<integer>x#0 <<< 1.0l</integer>;
	<half>x#0 >>> 1.0l</half>;
	<inexact>x#0 + 1.0l</inexact>;
	<inexact>x#0 - 1.0l</inexact>;
	<inexact>x#0 * 1.0l</inexact>;
	<integer>x#0 \ 1.0l</integer>;
	<inexact>x#0 / 1.0l</inexact>;
	<inexact>x#0 % 1.0l</inexact>;
    }
}"

test "void f(int8_t c, uint8_t uc, int16_t s, uint16_t us,
       int32_t i, uint32_t ui, int64_t l, uint64_t ul,
       float32_t f, float64_t d, auto v)
{
uint8_t x;+x;-x;~x;
x&c;x|c;x^c;x<<c;x>>c;x<<<c;x>>>c;x+c;x-c;x*c;x\\c;x/c;x%c;
x&uc;x|uc;x^uc;x<<uc;x>>uc;x<<<uc;x>>>uc;x+uc;x-uc;x*uc;x\\uc;x/uc;x%uc;
x&s;x|s;x^s;x<<s;x>>s;x<<<s;x>>>s;x+s;x-s;x*s;x\\s;x/s;x%s;
x&us;x|us;x^us;x<<us;x>>us;x<<<us;x>>>us;x+us;x-us;x*us;x\\us;x/us;x%us;
x&i;x|i;x^i;x<<i;x>>i;x<<<i;x>>>i;x+i;x-i;x*i;x\\i;x/i;x%i;
x&ui;x|ui;x^ui;x<<ui;x>>ui;x<<<ui;x>>>ui;x+ui;x-ui;x*ui;x\\ui;x/ui;x%ui;
x&l;x|l;x^l;x<<l;x>>l;x<<<l;x>>>l;x+l;x-l;x*l;x\\l;x/l;x%l;
x&ul;x|ul;x^ul;x<<ul;x>>ul;x<<<ul;x>>>ul;x+ul;x-ul;x*ul;x\\ul;x/ul;x%ul;
x&f;x|f;x^f;x<<f;x>>f;x<<<f;x>>>f;x+f;x-f;x*f;x\\f;x/f;x%f;
x&d;x|d;x^d;x<<d;x>>d;x<<<d;x>>>d;x+d;x-d;x*d;x\\d;x/d;x%d;
x&v;x|v;x^v;x<<v;x>>v;x<<<v;x>>>v;x+v;x-v;x*v;x\\v;x/v;x%v;
x+(1/2);x-(1/2);x*(1/2);x\\(1/2);x/(1/2);x%(1/2);
x<<1L;x>>1L;x<<<1L;x>>>1L;x+1L;x-1L;x*1L;x\\1L;x/1L;x%1L;
}" "
void () {
    void f(int8_t c#0, uint8_t uc#0, int16_t s#0, uint16_t us#0, int32_t i#0, uint32_t ui#0, int64_t l#0, uint64_t ul#0, float32_t f#0, float64_t d#0, auto v#0) {
	uint8_t x#0;
	<half>+x#0</half>;
	<word>-x#0</word>;
	<half>~x#0</half>;
	<half>x#0 & c#0</half>;
	<half>x#0 | c#0</half>;
	<half>x#0 ^ c#0</half>;
	<integer>x#0 << c#0</integer>;
	<exact>x#0 >> c#0</exact>;
	<integer>x#0 <<< c#0</integer>;
	<half>x#0 >>> c#0</half>;
	<word>x#0 + c#0</word>;
	<word>x#0 - c#0</word>;
	<word>x#0 * c#0</word>;
	<half>x#0 \ c#0</half>;
	<exact>x#0 / c#0</exact>;
	<half>x#0 % c#0</half>;
	<half>x#0 & uc#0</half>;
	<half>x#0 | uc#0</half>;
	<half>x#0 ^ uc#0</half>;
	<integer>x#0 << uc#0</integer>;
	<exact>x#0 >> uc#0</exact>;
	<integer>x#0 <<< uc#0</integer>;
	<half>x#0 >>> uc#0</half>;
	<word>x#0 + uc#0</word>;
	<word>x#0 - uc#0</word>;
	<word>x#0 * uc#0</word>;
	<half>x#0 \ uc#0</half>;
	<exact>x#0 / uc#0</exact>;
	<half>x#0 % uc#0</half>;
	<half>x#0 & s#0</half>;
	<half>x#0 | s#0</half>;
	<half>x#0 ^ s#0</half>;
	<integer>x#0 << s#0</integer>;
	<exact>x#0 >> s#0</exact>;
	<integer>x#0 <<< s#0</integer>;
	<half>x#0 >>> s#0</half>;
	<word>x#0 + s#0</word>;
	<word>x#0 - s#0</word>;
	<word>x#0 * s#0</word>;
	<half>x#0 \ s#0</half>;
	<exact>x#0 / s#0</exact>;
	<half>x#0 % s#0</half>;
	<half>x#0 & us#0</half>;
	<half>x#0 | us#0</half>;
	<half>x#0 ^ us#0</half>;
	<integer>x#0 << us#0</integer>;
	<exact>x#0 >> us#0</exact>;
	<integer>x#0 <<< us#0</integer>;
	<half>x#0 >>> us#0</half>;
	<word>x#0 + us#0</word>;
	<word>x#0 - us#0</word>;
	<word>x#0 * us#0</word>;
	<half>x#0 \ us#0</half>;
	<exact>x#0 / us#0</exact>;
	<half>x#0 % us#0</half>;
	<half>x#0 & i#0</half>;
	<half>x#0 | i#0</half>;
	<half>x#0 ^ i#0</half>;
	<integer>x#0 << i#0</integer>;
	<exact>x#0 >> i#0</exact>;
	<integer>x#0 <<< i#0</integer>;
	<half>x#0 >>> i#0</half>;
	<word>x#0 + i#0</word>;
	<word>x#0 - i#0</word>;
	<word>x#0 * i#0</word>;
	<half>x#0 \ i#0</half>;
	<exact>x#0 / i#0</exact>;
	<half>x#0 % i#0</half>;
	<half>x#0 & ui#0</half>;
	<word>x#0 | ui#0</word>;
	<word>x#0 ^ ui#0</word>;
	<integer>x#0 << ui#0</integer>;
	<exact>x#0 >> ui#0</exact>;
	<integer>x#0 <<< ui#0</integer>;
	<half>x#0 >>> ui#0</half>;
	<integer>x#0 + ui#0</integer>;
	<integer>x#0 - ui#0</integer>;
	<integer>x#0 * ui#0</integer>;
	<word>x#0 \ ui#0</word>;
	<exact>x#0 / ui#0</exact>;
	<word>x#0 % ui#0</word>;
	<half>x#0 & l#0</half>;
	<word>x#0 | l#0</word>;
	<word>x#0 ^ l#0</word>;
	<integer>x#0 << l#0</integer>;
	<exact>x#0 >> l#0</exact>;
	<integer>x#0 <<< l#0</integer>;
	<half>x#0 >>> l#0</half>;
	<integer>x#0 + l#0</integer>;
	<integer>x#0 - l#0</integer>;
	<integer>x#0 * l#0</integer>;
	<word>x#0 \ l#0</word>;
	<exact>x#0 / l#0</exact>;
	<word>x#0 % l#0</word>;
	<half>x#0 & ul#0</half>;
	<integer>x#0 | ul#0</integer>;
	<integer>x#0 ^ ul#0</integer>;
	<integer>x#0 << ul#0</integer>;
	<exact>x#0 >> ul#0</exact>;
	<integer>x#0 <<< ul#0</integer>;
	<half>x#0 >>> ul#0</half>;
	<integer>x#0 + ul#0</integer>;
	<integer>x#0 - ul#0</integer>;
	<integer>x#0 * ul#0</integer>;
	<integer>x#0 \ ul#0</integer>;
	<exact>x#0 / ul#0</exact>;
	<integer>x#0 % ul#0</integer>;
	<half>x#0 & f#0</half>;
	<integer>x#0 | f#0</integer>;
	<integer>x#0 ^ f#0</integer>;
	<integer>x#0 << f#0</integer>;
	<exact>x#0 >> f#0</exact>;
	<integer>x#0 <<< f#0</integer>;
	<half>x#0 >>> f#0</half>;
	<single>x#0 + f#0</single>;
	<single>x#0 - f#0</single>;
	<single>x#0 * f#0</single>;
	<integer>x#0 \ f#0</integer>;
	<single>x#0 / f#0</single>;
	<single>x#0 % f#0</single>;
	<half>x#0 & d#0</half>;
	<integer>x#0 | d#0</integer>;
	<integer>x#0 ^ d#0</integer>;
	<integer>x#0 << d#0</integer>;
	<exact>x#0 >> d#0</exact>;
	<integer>x#0 <<< d#0</integer>;
	<half>x#0 >>> d#0</half>;
	<float>x#0 + d#0</float>;
	<float>x#0 - d#0</float>;
	<float>x#0 * d#0</float>;
	<integer>x#0 \ d#0</integer>;
	<float>x#0 / d#0</float>;
	<float>x#0 % d#0</float>;
	<half>x#0 & v#0</half>;
	<integer>x#0 | v#0</integer>;
	<integer>x#0 ^ v#0</integer>;
	<undef>x#0 << v#0</undef>;
	<undef>x#0 >> v#0</undef>;
	<integer>x#0 <<< v#0</integer>;
	<half>x#0 >>> v#0</half>;
	<undef>x#0 + v#0</undef>;
	<undef>x#0 - v#0</undef>;
	<undef>x#0 * v#0</undef>;
	<integer>x#0 \ v#0</integer>;
	<undef>x#0 / v#0</undef>;
	<real>x#0 % v#0</real>;
	<exact>x#0 + 1/2</exact>;
	<exact>x#0 - 1/2</exact>;
	<exact>x#0 * 1/2</exact>;
	<integer>x#0 \ 1/2</integer>;
	<exact>x#0 / 1/2</exact>;
	<exact>x#0 % 1/2</exact>;
	<integer>x#0 << 1.0l</integer>;
	<exact>x#0 >> 1.0l</exact>;
	<integer>x#0 <<< 1.0l</integer>;
	<half>x#0 >>> 1.0l</half>;
	<inexact>x#0 + 1.0l</inexact>;
	<inexact>x#0 - 1.0l</inexact>;
	<inexact>x#0 * 1.0l</inexact>;
	<integer>x#0 \ 1.0l</integer>;
	<inexact>x#0 / 1.0l</inexact>;
	<inexact>x#0 % 1.0l</inexact>;
    }
}"

test "void f(int8_t c, uint8_t uc, int16_t s, uint16_t us,
       int32_t i, uint32_t ui, int64_t l, uint64_t ul,
       float32_t f, float64_t d, auto v)
{
int16_t x;+x;-x;~x;
x&c;x|c;x^c;x<<c;x>>c;x<<<c;x>>>c;x+c;x-c;x*c;x\\c;x/c;x%c;
x&uc;x|uc;x^uc;x<<uc;x>>uc;x<<<uc;x>>>uc;x+uc;x-uc;x*uc;x\\uc;x/uc;x%uc;
x&s;x|s;x^s;x<<s;x>>s;x<<<s;x>>>s;x+s;x-s;x*s;x\\s;x/s;x%s;
x&us;x|us;x^us;x<<us;x>>us;x<<<us;x>>>us;x+us;x-us;x*us;x\\us;x/us;x%us;
x&i;x|i;x^i;x<<i;x>>i;x<<<i;x>>>i;x+i;x-i;x*i;x\\i;x/i;x%i;
x&ui;x|ui;x^ui;x<<ui;x>>ui;x<<<ui;x>>>ui;x+ui;x-ui;x*ui;x\\ui;x/ui;x%ui;
x&l;x|l;x^l;x<<l;x>>l;x<<<l;x>>>l;x+l;x-l;x*l;x\\l;x/l;x%l;
x&ul;x|ul;x^ul;x<<ul;x>>ul;x<<<ul;x>>>ul;x+ul;x-ul;x*ul;x\\ul;x/ul;x%ul;
x&f;x|f;x^f;x<<f;x>>f;x<<<f;x>>>f;x+f;x-f;x*f;x\\f;x/f;x%f;
x&d;x|d;x^d;x<<d;x>>d;x<<<d;x>>>d;x+d;x-d;x*d;x\\d;x/d;x%d;
x&v;x|v;x^v;x<<v;x>>v;x<<<v;x>>>v;x+v;x-v;x*v;x\\v;x/v;x%v;
x+(1/2);x-(1/2);x*(1/2);x\\(1/2);x/(1/2);x%(1/2);
x<<1L;x>>1L;x<<<1L;x>>>1L;x+1L;x-1L;x*1L;x\\1L;x/1L;x%1L;
}" "
void () {
    void f(int8_t c#0, uint8_t uc#0, int16_t s#0, uint16_t us#0, int32_t i#0, uint32_t ui#0, int64_t l#0, uint64_t ul#0, float32_t f#0, float64_t d#0, auto v#0) {
	int16_t x#0;
	<half>+x#0</half>;
	<word>-x#0</word>;
	<half>~x#0</half>;
	<half>x#0 & c#0</half>;
	<half>x#0 | c#0</half>;
	<half>x#0 ^ c#0</half>;
	<integer>x#0 << c#0</integer>;
	<exact>x#0 >> c#0</exact>;
	<integer>x#0 <<< c#0</integer>;
	<half>x#0 >>> c#0</half>;
	<word>x#0 + c#0</word>;
	<word>x#0 - c#0</word>;
	<word>x#0 * c#0</word>;
	<half>x#0 \ c#0</half>;
	<exact>x#0 / c#0</exact>;
	<half>x#0 % c#0</half>;
	<half>x#0 & uc#0</half>;
	<half>x#0 | uc#0</half>;
	<half>x#0 ^ uc#0</half>;
	<integer>x#0 << uc#0</integer>;
	<exact>x#0 >> uc#0</exact>;
	<integer>x#0 <<< uc#0</integer>;
	<half>x#0 >>> uc#0</half>;
	<word>x#0 + uc#0</word>;
	<word>x#0 - uc#0</word>;
	<word>x#0 * uc#0</word>;
	<half>x#0 \ uc#0</half>;
	<exact>x#0 / uc#0</exact>;
	<half>x#0 % uc#0</half>;
	<half>x#0 & s#0</half>;
	<half>x#0 | s#0</half>;
	<half>x#0 ^ s#0</half>;
	<integer>x#0 << s#0</integer>;
	<exact>x#0 >> s#0</exact>;
	<integer>x#0 <<< s#0</integer>;
	<half>x#0 >>> s#0</half>;
	<word>x#0 + s#0</word>;
	<word>x#0 - s#0</word>;
	<word>x#0 * s#0</word>;
	<half>x#0 \ s#0</half>;
	<exact>x#0 / s#0</exact>;
	<half>x#0 % s#0</half>;
	<half>x#0 & us#0</half>;
	<half>x#0 | us#0</half>;
	<half>x#0 ^ us#0</half>;
	<integer>x#0 << us#0</integer>;
	<exact>x#0 >> us#0</exact>;
	<integer>x#0 <<< us#0</integer>;
	<half>x#0 >>> us#0</half>;
	<word>x#0 + us#0</word>;
	<word>x#0 - us#0</word>;
	<word>x#0 * us#0</word>;
	<half>x#0 \ us#0</half>;
	<exact>x#0 / us#0</exact>;
	<half>x#0 % us#0</half>;
	<half>x#0 & i#0</half>;
	<half>x#0 | i#0</half>;
	<half>x#0 ^ i#0</half>;
	<integer>x#0 << i#0</integer>;
	<exact>x#0 >> i#0</exact>;
	<integer>x#0 <<< i#0</integer>;
	<half>x#0 >>> i#0</half>;
	<word>x#0 + i#0</word>;
	<word>x#0 - i#0</word>;
	<word>x#0 * i#0</word>;
	<half>x#0 \ i#0</half>;
	<exact>x#0 / i#0</exact>;
	<half>x#0 % i#0</half>;
	<half>x#0 & ui#0</half>;
	<word>x#0 | ui#0</word>;
	<word>x#0 ^ ui#0</word>;
	<integer>x#0 << ui#0</integer>;
	<exact>x#0 >> ui#0</exact>;
	<integer>x#0 <<< ui#0</integer>;
	<half>x#0 >>> ui#0</half>;
	<integer>x#0 + ui#0</integer>;
	<integer>x#0 - ui#0</integer>;
	<integer>x#0 * ui#0</integer>;
	<word>x#0 \ ui#0</word>;
	<exact>x#0 / ui#0</exact>;
	<word>x#0 % ui#0</word>;
	<half>x#0 & l#0</half>;
	<word>x#0 | l#0</word>;
	<word>x#0 ^ l#0</word>;
	<integer>x#0 << l#0</integer>;
	<exact>x#0 >> l#0</exact>;
	<integer>x#0 <<< l#0</integer>;
	<half>x#0 >>> l#0</half>;
	<integer>x#0 + l#0</integer>;
	<integer>x#0 - l#0</integer>;
	<integer>x#0 * l#0</integer>;
	<word>x#0 \ l#0</word>;
	<exact>x#0 / l#0</exact>;
	<word>x#0 % l#0</word>;
	<half>x#0 & ul#0</half>;
	<integer>x#0 | ul#0</integer>;
	<integer>x#0 ^ ul#0</integer>;
	<integer>x#0 << ul#0</integer>;
	<exact>x#0 >> ul#0</exact>;
	<integer>x#0 <<< ul#0</integer>;
	<half>x#0 >>> ul#0</half>;
	<integer>x#0 + ul#0</integer>;
	<integer>x#0 - ul#0</integer>;
	<integer>x#0 * ul#0</integer>;
	<integer>x#0 \ ul#0</integer>;
	<exact>x#0 / ul#0</exact>;
	<integer>x#0 % ul#0</integer>;
	<half>x#0 & f#0</half>;
	<integer>x#0 | f#0</integer>;
	<integer>x#0 ^ f#0</integer>;
	<integer>x#0 << f#0</integer>;
	<exact>x#0 >> f#0</exact>;
	<integer>x#0 <<< f#0</integer>;
	<half>x#0 >>> f#0</half>;
	<single>x#0 + f#0</single>;
	<single>x#0 - f#0</single>;
	<single>x#0 * f#0</single>;
	<integer>x#0 \ f#0</integer>;
	<single>x#0 / f#0</single>;
	<single>x#0 % f#0</single>;
	<half>x#0 & d#0</half>;
	<integer>x#0 | d#0</integer>;
	<integer>x#0 ^ d#0</integer>;
	<integer>x#0 << d#0</integer>;
	<exact>x#0 >> d#0</exact>;
	<integer>x#0 <<< d#0</integer>;
	<half>x#0 >>> d#0</half>;
	<float>x#0 + d#0</float>;
	<float>x#0 - d#0</float>;
	<float>x#0 * d#0</float>;
	<integer>x#0 \ d#0</integer>;
	<float>x#0 / d#0</float>;
	<float>x#0 % d#0</float>;
	<half>x#0 & v#0</half>;
	<integer>x#0 | v#0</integer>;
	<integer>x#0 ^ v#0</integer>;
	<undef>x#0 << v#0</undef>;
	<undef>x#0 >> v#0</undef>;
	<integer>x#0 <<< v#0</integer>;
	<half>x#0 >>> v#0</half>;
	<undef>x#0 + v#0</undef>;
	<undef>x#0 - v#0</undef>;
	<undef>x#0 * v#0</undef>;
	<integer>x#0 \ v#0</integer>;
	<undef>x#0 / v#0</undef>;
	<real>x#0 % v#0</real>;
	<exact>x#0 + 1/2</exact>;
	<exact>x#0 - 1/2</exact>;
	<exact>x#0 * 1/2</exact>;
	<integer>x#0 \ 1/2</integer>;
	<exact>x#0 / 1/2</exact>;
	<exact>x#0 % 1/2</exact>;
	<integer>x#0 << 1.0l</integer>;
	<exact>x#0 >> 1.0l</exact>;
	<integer>x#0 <<< 1.0l</integer>;
	<half>x#0 >>> 1.0l</half>;
	<inexact>x#0 + 1.0l</inexact>;
	<inexact>x#0 - 1.0l</inexact>;
	<inexact>x#0 * 1.0l</inexact>;
	<integer>x#0 \ 1.0l</integer>;
	<inexact>x#0 / 1.0l</inexact>;
	<inexact>x#0 % 1.0l</inexact>;
    }
}"

test "void f(int8_t c, uint8_t uc, int16_t s, uint16_t us,
       int32_t i, uint32_t ui, int64_t l, uint64_t ul,
       float32_t f, float64_t d, auto v)
{
uint16_t x;+x;-x;~x;
x&c;x|c;x^c;x<<c;x>>c;x<<<c;x>>>c;x+c;x-c;x*c;x\\c;x/c;x%c;
x&uc;x|uc;x^uc;x<<uc;x>>uc;x<<<uc;x>>>uc;x+uc;x-uc;x*uc;x\\uc;x/uc;x%uc;
x&s;x|s;x^s;x<<s;x>>s;x<<<s;x>>>s;x+s;x-s;x*s;x\\s;x/s;x%s;
x&us;x|us;x^us;x<<us;x>>us;x<<<us;x>>>us;x+us;x-us;x*us;x\\us;x/us;x%us;
x&i;x|i;x^i;x<<i;x>>i;x<<<i;x>>>i;x+i;x-i;x*i;x\\i;x/i;x%i;
x&ui;x|ui;x^ui;x<<ui;x>>ui;x<<<ui;x>>>ui;x+ui;x-ui;x*ui;x\\ui;x/ui;x%ui;
x&l;x|l;x^l;x<<l;x>>l;x<<<l;x>>>l;x+l;x-l;x*l;x\\l;x/l;x%l;
x&ul;x|ul;x^ul;x<<ul;x>>ul;x<<<ul;x>>>ul;x+ul;x-ul;x*ul;x\\ul;x/ul;x%ul;
x&f;x|f;x^f;x<<f;x>>f;x<<<f;x>>>f;x+f;x-f;x*f;x\\f;x/f;x%f;
x&d;x|d;x^d;x<<d;x>>d;x<<<d;x>>>d;x+d;x-d;x*d;x\\d;x/d;x%d;
x&v;x|v;x^v;x<<v;x>>v;x<<<v;x>>>v;x+v;x-v;x*v;x\\v;x/v;x%v;
x+(1/2);x-(1/2);x*(1/2);x\\(1/2);x/(1/2);x%(1/2);
x<<1L;x>>1L;x<<<1L;x>>>1L;x+1L;x-1L;x*1L;x\\1L;x/1L;x%1L;
}" "
void () {
    void f(int8_t c#0, uint8_t uc#0, int16_t s#0, uint16_t us#0, int32_t i#0, uint32_t ui#0, int64_t l#0, uint64_t ul#0, float32_t f#0, float64_t d#0, auto v#0) {
	uint16_t x#0;
	<half>+x#0</half>;
	<word>-x#0</word>;
	<half>~x#0</half>;
	<half>x#0 & c#0</half>;
	<half>x#0 | c#0</half>;
	<half>x#0 ^ c#0</half>;
	<integer>x#0 << c#0</integer>;
	<exact>x#0 >> c#0</exact>;
	<integer>x#0 <<< c#0</integer>;
	<half>x#0 >>> c#0</half>;
	<word>x#0 + c#0</word>;
	<word>x#0 - c#0</word>;
	<word>x#0 * c#0</word>;
	<half>x#0 \ c#0</half>;
	<exact>x#0 / c#0</exact>;
	<half>x#0 % c#0</half>;
	<half>x#0 & uc#0</half>;
	<half>x#0 | uc#0</half>;
	<half>x#0 ^ uc#0</half>;
	<integer>x#0 << uc#0</integer>;
	<exact>x#0 >> uc#0</exact>;
	<integer>x#0 <<< uc#0</integer>;
	<half>x#0 >>> uc#0</half>;
	<word>x#0 + uc#0</word>;
	<word>x#0 - uc#0</word>;
	<word>x#0 * uc#0</word>;
	<half>x#0 \ uc#0</half>;
	<exact>x#0 / uc#0</exact>;
	<half>x#0 % uc#0</half>;
	<half>x#0 & s#0</half>;
	<half>x#0 | s#0</half>;
	<half>x#0 ^ s#0</half>;
	<integer>x#0 << s#0</integer>;
	<exact>x#0 >> s#0</exact>;
	<integer>x#0 <<< s#0</integer>;
	<half>x#0 >>> s#0</half>;
	<word>x#0 + s#0</word>;
	<word>x#0 - s#0</word>;
	<word>x#0 * s#0</word>;
	<half>x#0 \ s#0</half>;
	<exact>x#0 / s#0</exact>;
	<half>x#0 % s#0</half>;
	<half>x#0 & us#0</half>;
	<half>x#0 | us#0</half>;
	<half>x#0 ^ us#0</half>;
	<integer>x#0 << us#0</integer>;
	<exact>x#0 >> us#0</exact>;
	<integer>x#0 <<< us#0</integer>;
	<half>x#0 >>> us#0</half>;
	<word>x#0 + us#0</word>;
	<word>x#0 - us#0</word>;
	<word>x#0 * us#0</word>;
	<half>x#0 \ us#0</half>;
	<exact>x#0 / us#0</exact>;
	<half>x#0 % us#0</half>;
	<half>x#0 & i#0</half>;
	<half>x#0 | i#0</half>;
	<half>x#0 ^ i#0</half>;
	<integer>x#0 << i#0</integer>;
	<exact>x#0 >> i#0</exact>;
	<integer>x#0 <<< i#0</integer>;
	<half>x#0 >>> i#0</half>;
	<word>x#0 + i#0</word>;
	<word>x#0 - i#0</word>;
	<word>x#0 * i#0</word>;
	<half>x#0 \ i#0</half>;
	<exact>x#0 / i#0</exact>;
	<half>x#0 % i#0</half>;
	<half>x#0 & ui#0</half>;
	<word>x#0 | ui#0</word>;
	<word>x#0 ^ ui#0</word>;
	<integer>x#0 << ui#0</integer>;
	<exact>x#0 >> ui#0</exact>;
	<integer>x#0 <<< ui#0</integer>;
	<half>x#0 >>> ui#0</half>;
	<integer>x#0 + ui#0</integer>;
	<integer>x#0 - ui#0</integer>;
	<integer>x#0 * ui#0</integer>;
	<word>x#0 \ ui#0</word>;
	<exact>x#0 / ui#0</exact>;
	<word>x#0 % ui#0</word>;
	<half>x#0 & l#0</half>;
	<word>x#0 | l#0</word>;
	<word>x#0 ^ l#0</word>;
	<integer>x#0 << l#0</integer>;
	<exact>x#0 >> l#0</exact>;
	<integer>x#0 <<< l#0</integer>;
	<half>x#0 >>> l#0</half>;
	<integer>x#0 + l#0</integer>;
	<integer>x#0 - l#0</integer>;
	<integer>x#0 * l#0</integer>;
	<word>x#0 \ l#0</word>;
	<exact>x#0 / l#0</exact>;
	<word>x#0 % l#0</word>;
	<half>x#0 & ul#0</half>;
	<integer>x#0 | ul#0</integer>;
	<integer>x#0 ^ ul#0</integer>;
	<integer>x#0 << ul#0</integer>;
	<exact>x#0 >> ul#0</exact>;
	<integer>x#0 <<< ul#0</integer>;
	<half>x#0 >>> ul#0</half>;
	<integer>x#0 + ul#0</integer>;
	<integer>x#0 - ul#0</integer>;
	<integer>x#0 * ul#0</integer>;
	<integer>x#0 \ ul#0</integer>;
	<exact>x#0 / ul#0</exact>;
	<integer>x#0 % ul#0</integer>;
	<half>x#0 & f#0</half>;
	<integer>x#0 | f#0</integer>;
	<integer>x#0 ^ f#0</integer>;
	<integer>x#0 << f#0</integer>;
	<exact>x#0 >> f#0</exact>;
	<integer>x#0 <<< f#0</integer>;
	<half>x#0 >>> f#0</half>;
	<single>x#0 + f#0</single>;
	<single>x#0 - f#0</single>;
	<single>x#0 * f#0</single>;
	<integer>x#0 \ f#0</integer>;
	<single>x#0 / f#0</single>;
	<single>x#0 % f#0</single>;
	<half>x#0 & d#0</half>;
	<integer>x#0 | d#0</integer>;
	<integer>x#0 ^ d#0</integer>;
	<integer>x#0 << d#0</integer>;
	<exact>x#0 >> d#0</exact>;
	<integer>x#0 <<< d#0</integer>;
	<half>x#0 >>> d#0</half>;
	<float>x#0 + d#0</float>;
	<float>x#0 - d#0</float>;
	<float>x#0 * d#0</float>;
	<integer>x#0 \ d#0</integer>;
	<float>x#0 / d#0</float>;
	<float>x#0 % d#0</float>;
	<half>x#0 & v#0</half>;
	<integer>x#0 | v#0</integer>;
	<integer>x#0 ^ v#0</integer>;
	<undef>x#0 << v#0</undef>;
	<undef>x#0 >> v#0</undef>;
	<integer>x#0 <<< v#0</integer>;
	<half>x#0 >>> v#0</half>;
	<undef>x#0 + v#0</undef>;
	<undef>x#0 - v#0</undef>;
	<undef>x#0 * v#0</undef>;
	<integer>x#0 \ v#0</integer>;
	<undef>x#0 / v#0</undef>;
	<real>x#0 % v#0</real>;
	<exact>x#0 + 1/2</exact>;
	<exact>x#0 - 1/2</exact>;
	<exact>x#0 * 1/2</exact>;
	<integer>x#0 \ 1/2</integer>;
	<exact>x#0 / 1/2</exact>;
	<exact>x#0 % 1/2</exact>;
	<integer>x#0 << 1.0l</integer>;
	<exact>x#0 >> 1.0l</exact>;
	<integer>x#0 <<< 1.0l</integer>;
	<half>x#0 >>> 1.0l</half>;
	<inexact>x#0 + 1.0l</inexact>;
	<inexact>x#0 - 1.0l</inexact>;
	<inexact>x#0 * 1.0l</inexact>;
	<integer>x#0 \ 1.0l</integer>;
	<inexact>x#0 / 1.0l</inexact>;
	<inexact>x#0 % 1.0l</inexact>;
    }
}"

test "void f(int8_t c, uint8_t uc, int16_t s, uint16_t us,
       int32_t i, uint32_t ui, int64_t l, uint64_t ul,
       float32_t f, float64_t d, auto v)
{
int32_t x;+x;-x;~x;
x&c;x|c;x^c;x<<c;x>>c;x<<<c;x>>>c;x+c;x-c;x*c;x\\c;x/c;x%c;
x&uc;x|uc;x^uc;x<<uc;x>>uc;x<<<uc;x>>>uc;x+uc;x-uc;x*uc;x\\uc;x/uc;x%uc;
x&s;x|s;x^s;x<<s;x>>s;x<<<s;x>>>s;x+s;x-s;x*s;x\\s;x/s;x%s;
x&us;x|us;x^us;x<<us;x>>us;x<<<us;x>>>us;x+us;x-us;x*us;x\\us;x/us;x%us;
x&i;x|i;x^i;x<<i;x>>i;x<<<i;x>>>i;x+i;x-i;x*i;x\\i;x/i;x%i;
x&ui;x|ui;x^ui;x<<ui;x>>ui;x<<<ui;x>>>ui;x+ui;x-ui;x*ui;x\\ui;x/ui;x%ui;
x&l;x|l;x^l;x<<l;x>>l;x<<<l;x>>>l;x+l;x-l;x*l;x\\l;x/l;x%l;
x&ul;x|ul;x^ul;x<<ul;x>>ul;x<<<ul;x>>>ul;x+ul;x-ul;x*ul;x\\ul;x/ul;x%ul;
x&f;x|f;x^f;x<<f;x>>f;x<<<f;x>>>f;x+f;x-f;x*f;x\\f;x/f;x%f;
x&d;x|d;x^d;x<<d;x>>d;x<<<d;x>>>d;x+d;x-d;x*d;x\\d;x/d;x%d;
x&v;x|v;x^v;x<<v;x>>v;x<<<v;x>>>v;x+v;x-v;x*v;x\\v;x/v;x%v;
x+(1/2);x-(1/2);x*(1/2);x\\(1/2);x/(1/2);x%(1/2);
x<<1L;x>>1L;x<<<1L;x>>>1L;x+1L;x-1L;x*1L;x\\1L;x/1L;x%1L;
}" "
void () {
    void f(int8_t c#0, uint8_t uc#0, int16_t s#0, uint16_t us#0, int32_t i#0, uint32_t ui#0, int64_t l#0, uint64_t ul#0, float32_t f#0, float64_t d#0, auto v#0) {
	int32_t x#0;
	<half>+x#0</half>;
	<word>-x#0</word>;
	<half>~x#0</half>;
	<half>x#0 & c#0</half>;
	<half>x#0 | c#0</half>;
	<half>x#0 ^ c#0</half>;
	<integer>x#0 << c#0</integer>;
	<exact>x#0 >> c#0</exact>;
	<integer>x#0 <<< c#0</integer>;
	<half>x#0 >>> c#0</half>;
	<word>x#0 + c#0</word>;
	<word>x#0 - c#0</word>;
	<word>x#0 * c#0</word>;
	<half>x#0 \ c#0</half>;
	<exact>x#0 / c#0</exact>;
	<half>x#0 % c#0</half>;
	<half>x#0 & uc#0</half>;
	<half>x#0 | uc#0</half>;
	<half>x#0 ^ uc#0</half>;
	<integer>x#0 << uc#0</integer>;
	<exact>x#0 >> uc#0</exact>;
	<integer>x#0 <<< uc#0</integer>;
	<half>x#0 >>> uc#0</half>;
	<word>x#0 + uc#0</word>;
	<word>x#0 - uc#0</word>;
	<word>x#0 * uc#0</word>;
	<half>x#0 \ uc#0</half>;
	<exact>x#0 / uc#0</exact>;
	<half>x#0 % uc#0</half>;
	<half>x#0 & s#0</half>;
	<half>x#0 | s#0</half>;
	<half>x#0 ^ s#0</half>;
	<integer>x#0 << s#0</integer>;
	<exact>x#0 >> s#0</exact>;
	<integer>x#0 <<< s#0</integer>;
	<half>x#0 >>> s#0</half>;
	<word>x#0 + s#0</word>;
	<word>x#0 - s#0</word>;
	<word>x#0 * s#0</word>;
	<half>x#0 \ s#0</half>;
	<exact>x#0 / s#0</exact>;
	<half>x#0 % s#0</half>;
	<half>x#0 & us#0</half>;
	<half>x#0 | us#0</half>;
	<half>x#0 ^ us#0</half>;
	<integer>x#0 << us#0</integer>;
	<exact>x#0 >> us#0</exact>;
	<integer>x#0 <<< us#0</integer>;
	<half>x#0 >>> us#0</half>;
	<word>x#0 + us#0</word>;
	<word>x#0 - us#0</word>;
	<word>x#0 * us#0</word>;
	<half>x#0 \ us#0</half>;
	<exact>x#0 / us#0</exact>;
	<half>x#0 % us#0</half>;
	<half>x#0 & i#0</half>;
	<half>x#0 | i#0</half>;
	<half>x#0 ^ i#0</half>;
	<integer>x#0 << i#0</integer>;
	<exact>x#0 >> i#0</exact>;
	<integer>x#0 <<< i#0</integer>;
	<half>x#0 >>> i#0</half>;
	<word>x#0 + i#0</word>;
	<word>x#0 - i#0</word>;
	<word>x#0 * i#0</word>;
	<half>x#0 \ i#0</half>;
	<exact>x#0 / i#0</exact>;
	<half>x#0 % i#0</half>;
	<half>x#0 & ui#0</half>;
	<word>x#0 | ui#0</word>;
	<word>x#0 ^ ui#0</word>;
	<integer>x#0 << ui#0</integer>;
	<exact>x#0 >> ui#0</exact>;
	<integer>x#0 <<< ui#0</integer>;
	<half>x#0 >>> ui#0</half>;
	<integer>x#0 + ui#0</integer>;
	<integer>x#0 - ui#0</integer>;
	<integer>x#0 * ui#0</integer>;
	<word>x#0 \ ui#0</word>;
	<exact>x#0 / ui#0</exact>;
	<word>x#0 % ui#0</word>;
	<half>x#0 & l#0</half>;
	<word>x#0 | l#0</word>;
	<word>x#0 ^ l#0</word>;
	<integer>x#0 << l#0</integer>;
	<exact>x#0 >> l#0</exact>;
	<integer>x#0 <<< l#0</integer>;
	<half>x#0 >>> l#0</half>;
	<integer>x#0 + l#0</integer>;
	<integer>x#0 - l#0</integer>;
	<integer>x#0 * l#0</integer>;
	<word>x#0 \ l#0</word>;
	<exact>x#0 / l#0</exact>;
	<word>x#0 % l#0</word>;
	<half>x#0 & ul#0</half>;
	<integer>x#0 | ul#0</integer>;
	<integer>x#0 ^ ul#0</integer>;
	<integer>x#0 << ul#0</integer>;
	<exact>x#0 >> ul#0</exact>;
	<integer>x#0 <<< ul#0</integer>;
	<half>x#0 >>> ul#0</half>;
	<integer>x#0 + ul#0</integer>;
	<integer>x#0 - ul#0</integer>;
	<integer>x#0 * ul#0</integer>;
	<integer>x#0 \ ul#0</integer>;
	<exact>x#0 / ul#0</exact>;
	<integer>x#0 % ul#0</integer>;
	<half>x#0 & f#0</half>;
	<integer>x#0 | f#0</integer>;
	<integer>x#0 ^ f#0</integer>;
	<integer>x#0 << f#0</integer>;
	<exact>x#0 >> f#0</exact>;
	<integer>x#0 <<< f#0</integer>;
	<half>x#0 >>> f#0</half>;
	<single>x#0 + f#0</single>;
	<single>x#0 - f#0</single>;
	<single>x#0 * f#0</single>;
	<integer>x#0 \ f#0</integer>;
	<single>x#0 / f#0</single>;
	<single>x#0 % f#0</single>;
	<half>x#0 & d#0</half>;
	<integer>x#0 | d#0</integer>;
	<integer>x#0 ^ d#0</integer>;
	<integer>x#0 << d#0</integer>;
	<exact>x#0 >> d#0</exact>;
	<integer>x#0 <<< d#0</integer>;
	<half>x#0 >>> d#0</half>;
	<float>x#0 + d#0</float>;
	<float>x#0 - d#0</float>;
	<float>x#0 * d#0</float>;
	<integer>x#0 \ d#0</integer>;
	<float>x#0 / d#0</float>;
	<float>x#0 % d#0</float>;
	<half>x#0 & v#0</half>;
	<integer>x#0 | v#0</integer>;
	<integer>x#0 ^ v#0</integer>;
	<undef>x#0 << v#0</undef>;
	<undef>x#0 >> v#0</undef>;
	<integer>x#0 <<< v#0</integer>;
	<half>x#0 >>> v#0</half>;
	<undef>x#0 + v#0</undef>;
	<undef>x#0 - v#0</undef>;
	<undef>x#0 * v#0</undef>;
	<integer>x#0 \ v#0</integer>;
	<undef>x#0 / v#0</undef>;
	<real>x#0 % v#0</real>;
	<exact>x#0 + 1/2</exact>;
	<exact>x#0 - 1/2</exact>;
	<exact>x#0 * 1/2</exact>;
	<integer>x#0 \ 1/2</integer>;
	<exact>x#0 / 1/2</exact>;
	<exact>x#0 % 1/2</exact>;
	<integer>x#0 << 1.0l</integer>;
	<exact>x#0 >> 1.0l</exact>;
	<integer>x#0 <<< 1.0l</integer>;
	<half>x#0 >>> 1.0l</half>;
	<inexact>x#0 + 1.0l</inexact>;
	<inexact>x#0 - 1.0l</inexact>;
	<inexact>x#0 * 1.0l</inexact>;
	<integer>x#0 \ 1.0l</integer>;
	<inexact>x#0 / 1.0l</inexact>;
	<inexact>x#0 % 1.0l</inexact>;
    }
}"

test "void f(int8_t c, uint8_t uc, int16_t s, uint16_t us,
       int32_t i, uint32_t ui, int64_t l, uint64_t ul,
       float32_t f, float64_t d, auto v)
{
uint32_t x;+x;-x;~x;
x&c;x|c;x^c;x<<c;x>>c;x<<<c;x>>>c;x+c;x-c;x*c;x\\c;x/c;x%c;
x&uc;x|uc;x^uc;x<<uc;x>>uc;x<<<uc;x>>>uc;x+uc;x-uc;x*uc;x\\uc;x/uc;x%uc;
x&s;x|s;x^s;x<<s;x>>s;x<<<s;x>>>s;x+s;x-s;x*s;x\\s;x/s;x%s;
x&us;x|us;x^us;x<<us;x>>us;x<<<us;x>>>us;x+us;x-us;x*us;x\\us;x/us;x%us;
x&i;x|i;x^i;x<<i;x>>i;x<<<i;x>>>i;x+i;x-i;x*i;x\\i;x/i;x%i;
x&ui;x|ui;x^ui;x<<ui;x>>ui;x<<<ui;x>>>ui;x+ui;x-ui;x*ui;x\\ui;x/ui;x%ui;
x&l;x|l;x^l;x<<l;x>>l;x<<<l;x>>>l;x+l;x-l;x*l;x\\l;x/l;x%l;
x&ul;x|ul;x^ul;x<<ul;x>>ul;x<<<ul;x>>>ul;x+ul;x-ul;x*ul;x\\ul;x/ul;x%ul;
x&f;x|f;x^f;x<<f;x>>f;x<<<f;x>>>f;x+f;x-f;x*f;x\\f;x/f;x%f;
x&d;x|d;x^d;x<<d;x>>d;x<<<d;x>>>d;x+d;x-d;x*d;x\\d;x/d;x%d;
x&v;x|v;x^v;x<<v;x>>v;x<<<v;x>>>v;x+v;x-v;x*v;x\\v;x/v;x%v;
x+(1/2);x-(1/2);x*(1/2);x\\(1/2);x/(1/2);x%(1/2);
x<<1L;x>>1L;x<<<1L;x>>>1L;x+1L;x-1L;x*1L;x\\1L;x/1L;x%1L;
}" "
void () {
    void f(int8_t c#0, uint8_t uc#0, int16_t s#0, uint16_t us#0, int32_t i#0, uint32_t ui#0, int64_t l#0, uint64_t ul#0, float32_t f#0, float64_t d#0, auto v#0) {
	uint32_t x#0;
	<word>+x#0</word>;
	<integer>-x#0</integer>;
	<word>~x#0</word>;
	<half>x#0 & c#0</half>;
	<word>x#0 | c#0</word>;
	<word>x#0 ^ c#0</word>;
	<integer>x#0 << c#0</integer>;
	<exact>x#0 >> c#0</exact>;
	<integer>x#0 <<< c#0</integer>;
	<word>x#0 >>> c#0</word>;
	<integer>x#0 + c#0</integer>;
	<integer>x#0 - c#0</integer>;
	<integer>x#0 * c#0</integer>;
	<word>x#0 \ c#0</word>;
	<exact>x#0 / c#0</exact>;
	<word>x#0 % c#0</word>;
	<half>x#0 & uc#0</half>;
	<word>x#0 | uc#0</word>;
	<word>x#0 ^ uc#0</word>;
	<integer>x#0 << uc#0</integer>;
	<exact>x#0 >> uc#0</exact>;
	<integer>x#0 <<< uc#0</integer>;
	<word>x#0 >>> uc#0</word>;
	<integer>x#0 + uc#0</integer>;
	<integer>x#0 - uc#0</integer>;
	<integer>x#0 * uc#0</integer>;
	<word>x#0 \ uc#0</word>;
	<exact>x#0 / uc#0</exact>;
	<word>x#0 % uc#0</word>;
	<half>x#0 & s#0</half>;
	<word>x#0 | s#0</word>;
	<word>x#0 ^ s#0</word>;
	<integer>x#0 << s#0</integer>;
	<exact>x#0 >> s#0</exact>;
	<integer>x#0 <<< s#0</integer>;
	<word>x#0 >>> s#0</word>;
	<integer>x#0 + s#0</integer>;
	<integer>x#0 - s#0</integer>;
	<integer>x#0 * s#0</integer>;
	<word>x#0 \ s#0</word>;
	<exact>x#0 / s#0</exact>;
	<word>x#0 % s#0</word>;
	<half>x#0 & us#0</half>;
	<word>x#0 | us#0</word>;
	<word>x#0 ^ us#0</word>;
	<integer>x#0 << us#0</integer>;
	<exact>x#0 >> us#0</exact>;
	<integer>x#0 <<< us#0</integer>;
	<word>x#0 >>> us#0</word>;
	<integer>x#0 + us#0</integer>;
	<integer>x#0 - us#0</integer>;
	<integer>x#0 * us#0</integer>;
	<word>x#0 \ us#0</word>;
	<exact>x#0 / us#0</exact>;
	<word>x#0 % us#0</word>;
	<half>x#0 & i#0</half>;
	<word>x#0 | i#0</word>;
	<word>x#0 ^ i#0</word>;
	<integer>x#0 << i#0</integer>;
	<exact>x#0 >> i#0</exact>;
	<integer>x#0 <<< i#0</integer>;
	<word>x#0 >>> i#0</word>;
	<integer>x#0 + i#0</integer>;
	<integer>x#0 - i#0</integer>;
	<integer>x#0 * i#0</integer>;
	<word>x#0 \ i#0</word>;
	<exact>x#0 / i#0</exact>;
	<word>x#0 % i#0</word>;
	<word>x#0 & ui#0</word>;
	<word>x#0 | ui#0</word>;
	<word>x#0 ^ ui#0</word>;
	<integer>x#0 << ui#0</integer>;
	<exact>x#0 >> ui#0</exact>;
	<integer>x#0 <<< ui#0</integer>;
	<word>x#0 >>> ui#0</word>;
	<integer>x#0 + ui#0</integer>;
	<integer>x#0 - ui#0</integer>;
	<integer>x#0 * ui#0</integer>;
	<word>x#0 \ ui#0</word>;
	<exact>x#0 / ui#0</exact>;
	<word>x#0 % ui#0</word>;
	<word>x#0 & l#0</word>;
	<word>x#0 | l#0</word>;
	<word>x#0 ^ l#0</word>;
	<integer>x#0 << l#0</integer>;
	<exact>x#0 >> l#0</exact>;
	<integer>x#0 <<< l#0</integer>;
	<word>x#0 >>> l#0</word>;
	<integer>x#0 + l#0</integer>;
	<integer>x#0 - l#0</integer>;
	<integer>x#0 * l#0</integer>;
	<word>x#0 \ l#0</word>;
	<exact>x#0 / l#0</exact>;
	<word>x#0 % l#0</word>;
	<word>x#0 & ul#0</word>;
	<integer>x#0 | ul#0</integer>;
	<integer>x#0 ^ ul#0</integer>;
	<integer>x#0 << ul#0</integer>;
	<exact>x#0 >> ul#0</exact>;
	<integer>x#0 <<< ul#0</integer>;
	<word>x#0 >>> ul#0</word>;
	<integer>x#0 + ul#0</integer>;
	<integer>x#0 - ul#0</integer>;
	<integer>x#0 * ul#0</integer>;
	<integer>x#0 \ ul#0</integer>;
	<exact>x#0 / ul#0</exact>;
	<integer>x#0 % ul#0</integer>;
	<word>x#0 & f#0</word>;
	<integer>x#0 | f#0</integer>;
	<integer>x#0 ^ f#0</integer>;
	<integer>x#0 << f#0</integer>;
	<exact>x#0 >> f#0</exact>;
	<integer>x#0 <<< f#0</integer>;
	<word>x#0 >>> f#0</word>;
	<single>x#0 + f#0</single>;
	<single>x#0 - f#0</single>;
	<single>x#0 * f#0</single>;
	<integer>x#0 \ f#0</integer>;
	<single>x#0 / f#0</single>;
	<single>x#0 % f#0</single>;
	<word>x#0 & d#0</word>;
	<integer>x#0 | d#0</integer>;
	<integer>x#0 ^ d#0</integer>;
	<integer>x#0 << d#0</integer>;
	<exact>x#0 >> d#0</exact>;
	<integer>x#0 <<< d#0</integer>;
	<word>x#0 >>> d#0</word>;
	<float>x#0 + d#0</float>;
	<float>x#0 - d#0</float>;
	<float>x#0 * d#0</float>;
	<integer>x#0 \ d#0</integer>;
	<float>x#0 / d#0</float>;
	<float>x#0 % d#0</float>;
	<word>x#0 & v#0</word>;
	<integer>x#0 | v#0</integer>;
	<integer>x#0 ^ v#0</integer>;
	<undef>x#0 << v#0</undef>;
	<undef>x#0 >> v#0</undef>;
	<integer>x#0 <<< v#0</integer>;
	<word>x#0 >>> v#0</word>;
	<undef>x#0 + v#0</undef>;
	<undef>x#0 - v#0</undef>;
	<undef>x#0 * v#0</undef>;
	<integer>x#0 \ v#0</integer>;
	<undef>x#0 / v#0</undef>;
	<real>x#0 % v#0</real>;
	<exact>x#0 + 1/2</exact>;
	<exact>x#0 - 1/2</exact>;
	<exact>x#0 * 1/2</exact>;
	<integer>x#0 \ 1/2</integer>;
	<exact>x#0 / 1/2</exact>;
	<exact>x#0 % 1/2</exact>;
	<integer>x#0 << 1.0l</integer>;
	<exact>x#0 >> 1.0l</exact>;
	<integer>x#0 <<< 1.0l</integer>;
	<word>x#0 >>> 1.0l</word>;
	<inexact>x#0 + 1.0l</inexact>;
	<inexact>x#0 - 1.0l</inexact>;
	<inexact>x#0 * 1.0l</inexact>;
	<integer>x#0 \ 1.0l</integer>;
	<inexact>x#0 / 1.0l</inexact>;
	<inexact>x#0 % 1.0l</inexact>;
    }
}"

test "void f(int8_t c, uint8_t uc, int16_t s, uint16_t us,
       int32_t i, uint32_t ui, int64_t l, uint64_t ul,
       float32_t f, float64_t d, auto v)
{
int64_t x;+x;-x;~x;
x&c;x|c;x^c;x<<c;x>>c;x<<<c;x>>>c;x+c;x-c;x*c;x\\c;x/c;x%c;
x&uc;x|uc;x^uc;x<<uc;x>>uc;x<<<uc;x>>>uc;x+uc;x-uc;x*uc;x\\uc;x/uc;x%uc;
x&s;x|s;x^s;x<<s;x>>s;x<<<s;x>>>s;x+s;x-s;x*s;x\\s;x/s;x%s;
x&us;x|us;x^us;x<<us;x>>us;x<<<us;x>>>us;x+us;x-us;x*us;x\\us;x/us;x%us;
x&i;x|i;x^i;x<<i;x>>i;x<<<i;x>>>i;x+i;x-i;x*i;x\\i;x/i;x%i;
x&ui;x|ui;x^ui;x<<ui;x>>ui;x<<<ui;x>>>ui;x+ui;x-ui;x*ui;x\\ui;x/ui;x%ui;
x&l;x|l;x^l;x<<l;x>>l;x<<<l;x>>>l;x+l;x-l;x*l;x\\l;x/l;x%l;
x&ul;x|ul;x^ul;x<<ul;x>>ul;x<<<ul;x>>>ul;x+ul;x-ul;x*ul;x\\ul;x/ul;x%ul;
x&f;x|f;x^f;x<<f;x>>f;x<<<f;x>>>f;x+f;x-f;x*f;x\\f;x/f;x%f;
x&d;x|d;x^d;x<<d;x>>d;x<<<d;x>>>d;x+d;x-d;x*d;x\\d;x/d;x%d;
x&v;x|v;x^v;x<<v;x>>v;x<<<v;x>>>v;x+v;x-v;x*v;x\\v;x/v;x%v;
x+(1/2);x-(1/2);x*(1/2);x\\(1/2);x/(1/2);x%(1/2);
x<<1L;x>>1L;x<<<1L;x>>>1L;x+1L;x-1L;x*1L;x\\1L;x/1L;x%1L;
}" "
void () {
    void f(int8_t c#0, uint8_t uc#0, int16_t s#0, uint16_t us#0, int32_t i#0, uint32_t ui#0, int64_t l#0, uint64_t ul#0, float32_t f#0, float64_t d#0, auto v#0) {
	int64_t x#0;
	<word>+x#0</word>;
	<integer>-x#0</integer>;
	<word>~x#0</word>;
	<half>x#0 & c#0</half>;
	<word>x#0 | c#0</word>;
	<word>x#0 ^ c#0</word>;
	<integer>x#0 << c#0</integer>;
	<exact>x#0 >> c#0</exact>;
	<integer>x#0 <<< c#0</integer>;
	<word>x#0 >>> c#0</word>;
	<integer>x#0 + c#0</integer>;
	<integer>x#0 - c#0</integer>;
	<integer>x#0 * c#0</integer>;
	<word>x#0 \ c#0</word>;
	<exact>x#0 / c#0</exact>;
	<word>x#0 % c#0</word>;
	<half>x#0 & uc#0</half>;
	<word>x#0 | uc#0</word>;
	<word>x#0 ^ uc#0</word>;
	<integer>x#0 << uc#0</integer>;
	<exact>x#0 >> uc#0</exact>;
	<integer>x#0 <<< uc#0</integer>;
	<word>x#0 >>> uc#0</word>;
	<integer>x#0 + uc#0</integer>;
	<integer>x#0 - uc#0</integer>;
	<integer>x#0 * uc#0</integer>;
	<word>x#0 \ uc#0</word>;
	<exact>x#0 / uc#0</exact>;
	<word>x#0 % uc#0</word>;
	<half>x#0 & s#0</half>;
	<word>x#0 | s#0</word>;
	<word>x#0 ^ s#0</word>;
	<integer>x#0 << s#0</integer>;
	<exact>x#0 >> s#0</exact>;
	<integer>x#0 <<< s#0</integer>;
	<word>x#0 >>> s#0</word>;
	<integer>x#0 + s#0</integer>;
	<integer>x#0 - s#0</integer>;
	<integer>x#0 * s#0</integer>;
	<word>x#0 \ s#0</word>;
	<exact>x#0 / s#0</exact>;
	<word>x#0 % s#0</word>;
	<half>x#0 & us#0</half>;
	<word>x#0 | us#0</word>;
	<word>x#0 ^ us#0</word>;
	<integer>x#0 << us#0</integer>;
	<exact>x#0 >> us#0</exact>;
	<integer>x#0 <<< us#0</integer>;
	<word>x#0 >>> us#0</word>;
	<integer>x#0 + us#0</integer>;
	<integer>x#0 - us#0</integer>;
	<integer>x#0 * us#0</integer>;
	<word>x#0 \ us#0</word>;
	<exact>x#0 / us#0</exact>;
	<word>x#0 % us#0</word>;
	<half>x#0 & i#0</half>;
	<word>x#0 | i#0</word>;
	<word>x#0 ^ i#0</word>;
	<integer>x#0 << i#0</integer>;
	<exact>x#0 >> i#0</exact>;
	<integer>x#0 <<< i#0</integer>;
	<word>x#0 >>> i#0</word>;
	<integer>x#0 + i#0</integer>;
	<integer>x#0 - i#0</integer>;
	<integer>x#0 * i#0</integer>;
	<word>x#0 \ i#0</word>;
	<exact>x#0 / i#0</exact>;
	<word>x#0 % i#0</word>;
	<word>x#0 & ui#0</word>;
	<word>x#0 | ui#0</word>;
	<word>x#0 ^ ui#0</word>;
	<integer>x#0 << ui#0</integer>;
	<exact>x#0 >> ui#0</exact>;
	<integer>x#0 <<< ui#0</integer>;
	<word>x#0 >>> ui#0</word>;
	<integer>x#0 + ui#0</integer>;
	<integer>x#0 - ui#0</integer>;
	<integer>x#0 * ui#0</integer>;
	<word>x#0 \ ui#0</word>;
	<exact>x#0 / ui#0</exact>;
	<word>x#0 % ui#0</word>;
	<word>x#0 & l#0</word>;
	<word>x#0 | l#0</word>;
	<word>x#0 ^ l#0</word>;
	<integer>x#0 << l#0</integer>;
	<exact>x#0 >> l#0</exact>;
	<integer>x#0 <<< l#0</integer>;
	<word>x#0 >>> l#0</word>;
	<integer>x#0 + l#0</integer>;
	<integer>x#0 - l#0</integer>;
	<integer>x#0 * l#0</integer>;
	<word>x#0 \ l#0</word>;
	<exact>x#0 / l#0</exact>;
	<word>x#0 % l#0</word>;
	<word>x#0 & ul#0</word>;
	<integer>x#0 | ul#0</integer>;
	<integer>x#0 ^ ul#0</integer>;
	<integer>x#0 << ul#0</integer>;
	<exact>x#0 >> ul#0</exact>;
	<integer>x#0 <<< ul#0</integer>;
	<word>x#0 >>> ul#0</word>;
	<integer>x#0 + ul#0</integer>;
	<integer>x#0 - ul#0</integer>;
	<integer>x#0 * ul#0</integer>;
	<integer>x#0 \ ul#0</integer>;
	<exact>x#0 / ul#0</exact>;
	<integer>x#0 % ul#0</integer>;
	<word>x#0 & f#0</word>;
	<integer>x#0 | f#0</integer>;
	<integer>x#0 ^ f#0</integer>;
	<integer>x#0 << f#0</integer>;
	<exact>x#0 >> f#0</exact>;
	<integer>x#0 <<< f#0</integer>;
	<word>x#0 >>> f#0</word>;
	<single>x#0 + f#0</single>;
	<single>x#0 - f#0</single>;
	<single>x#0 * f#0</single>;
	<integer>x#0 \ f#0</integer>;
	<single>x#0 / f#0</single>;
	<single>x#0 % f#0</single>;
	<word>x#0 & d#0</word>;
	<integer>x#0 | d#0</integer>;
	<integer>x#0 ^ d#0</integer>;
	<integer>x#0 << d#0</integer>;
	<exact>x#0 >> d#0</exact>;
	<integer>x#0 <<< d#0</integer>;
	<word>x#0 >>> d#0</word>;
	<float>x#0 + d#0</float>;
	<float>x#0 - d#0</float>;
	<float>x#0 * d#0</float>;
	<integer>x#0 \ d#0</integer>;
	<float>x#0 / d#0</float>;
	<float>x#0 % d#0</float>;
	<word>x#0 & v#0</word>;
	<integer>x#0 | v#0</integer>;
	<integer>x#0 ^ v#0</integer>;
	<undef>x#0 << v#0</undef>;
	<undef>x#0 >> v#0</undef>;
	<integer>x#0 <<< v#0</integer>;
	<word>x#0 >>> v#0</word>;
	<undef>x#0 + v#0</undef>;
	<undef>x#0 - v#0</undef>;
	<undef>x#0 * v#0</undef>;
	<integer>x#0 \ v#0</integer>;
	<undef>x#0 / v#0</undef>;
	<real>x#0 % v#0</real>;
	<exact>x#0 + 1/2</exact>;
	<exact>x#0 - 1/2</exact>;
	<exact>x#0 * 1/2</exact>;
	<integer>x#0 \ 1/2</integer>;
	<exact>x#0 / 1/2</exact>;
	<exact>x#0 % 1/2</exact>;
	<integer>x#0 << 1.0l</integer>;
	<exact>x#0 >> 1.0l</exact>;
	<integer>x#0 <<< 1.0l</integer>;
	<word>x#0 >>> 1.0l</word>;
	<inexact>x#0 + 1.0l</inexact>;
	<inexact>x#0 - 1.0l</inexact>;
	<inexact>x#0 * 1.0l</inexact>;
	<integer>x#0 \ 1.0l</integer>;
	<inexact>x#0 / 1.0l</inexact>;
	<inexact>x#0 % 1.0l</inexact>;
    }
}"

test "void f(int8_t c, uint8_t uc, int16_t s, uint16_t us,
       int32_t i, uint32_t ui, int64_t l, uint64_t ul,
       float32_t f, float64_t d, auto v)
{
uint64_t x;+x;-x;~x;
x&c;x|c;x^c;x<<c;x>>c;x<<<c;x>>>c;x+c;x-c;x*c;x\\c;x/c;x%c;
x&uc;x|uc;x^uc;x<<uc;x>>uc;x<<<uc;x>>>uc;x+uc;x-uc;x*uc;x\\uc;x/uc;x%uc;
x&s;x|s;x^s;x<<s;x>>s;x<<<s;x>>>s;x+s;x-s;x*s;x\\s;x/s;x%s;
x&us;x|us;x^us;x<<us;x>>us;x<<<us;x>>>us;x+us;x-us;x*us;x\\us;x/us;x%us;
x&i;x|i;x^i;x<<i;x>>i;x<<<i;x>>>i;x+i;x-i;x*i;x\\i;x/i;x%i;
x&ui;x|ui;x^ui;x<<ui;x>>ui;x<<<ui;x>>>ui;x+ui;x-ui;x*ui;x\\ui;x/ui;x%ui;
x&l;x|l;x^l;x<<l;x>>l;x<<<l;x>>>l;x+l;x-l;x*l;x\\l;x/l;x%l;
x&ul;x|ul;x^ul;x<<ul;x>>ul;x<<<ul;x>>>ul;x+ul;x-ul;x*ul;x\\ul;x/ul;x%ul;
x&f;x|f;x^f;x<<f;x>>f;x<<<f;x>>>f;x+f;x-f;x*f;x\\f;x/f;x%f;
x&d;x|d;x^d;x<<d;x>>d;x<<<d;x>>>d;x+d;x-d;x*d;x\\d;x/d;x%d;
x&v;x|v;x^v;x<<v;x>>v;x<<<v;x>>>v;x+v;x-v;x*v;x\\v;x/v;x%v;
x+(1/2);x-(1/2);x*(1/2);x\\(1/2);x/(1/2);x%(1/2);
x<<1L;x>>1L;x<<<1L;x>>>1L;x+1L;x-1L;x*1L;x\\1L;x/1L;x%1L;
}" "
void () {
    void f(int8_t c#0, uint8_t uc#0, int16_t s#0, uint16_t us#0, int32_t i#0, uint32_t ui#0, int64_t l#0, uint64_t ul#0, float32_t f#0, float64_t d#0, auto v#0) {
	uint64_t x#0;
	<integer>+x#0</integer>;
	<integer>-x#0</integer>;
	<integer>~x#0</integer>;
	<half>x#0 & c#0</half>;
	<integer>x#0 | c#0</integer>;
	<integer>x#0 ^ c#0</integer>;
	<integer>x#0 << c#0</integer>;
	<exact>x#0 >> c#0</exact>;
	<integer>x#0 <<< c#0</integer>;
	<integer>x#0 >>> c#0</integer>;
	<integer>x#0 + c#0</integer>;
	<integer>x#0 - c#0</integer>;
	<integer>x#0 * c#0</integer>;
	<integer>x#0 \ c#0</integer>;
	<exact>x#0 / c#0</exact>;
	<integer>x#0 % c#0</integer>;
	<half>x#0 & uc#0</half>;
	<integer>x#0 | uc#0</integer>;
	<integer>x#0 ^ uc#0</integer>;
	<integer>x#0 << uc#0</integer>;
	<exact>x#0 >> uc#0</exact>;
	<integer>x#0 <<< uc#0</integer>;
	<integer>x#0 >>> uc#0</integer>;
	<integer>x#0 + uc#0</integer>;
	<integer>x#0 - uc#0</integer>;
	<integer>x#0 * uc#0</integer>;
	<integer>x#0 \ uc#0</integer>;
	<exact>x#0 / uc#0</exact>;
	<integer>x#0 % uc#0</integer>;
	<half>x#0 & s#0</half>;
	<integer>x#0 | s#0</integer>;
	<integer>x#0 ^ s#0</integer>;
	<integer>x#0 << s#0</integer>;
	<exact>x#0 >> s#0</exact>;
	<integer>x#0 <<< s#0</integer>;
	<integer>x#0 >>> s#0</integer>;
	<integer>x#0 + s#0</integer>;
	<integer>x#0 - s#0</integer>;
	<integer>x#0 * s#0</integer>;
	<integer>x#0 \ s#0</integer>;
	<exact>x#0 / s#0</exact>;
	<integer>x#0 % s#0</integer>;
	<half>x#0 & us#0</half>;
	<integer>x#0 | us#0</integer>;
	<integer>x#0 ^ us#0</integer>;
	<integer>x#0 << us#0</integer>;
	<exact>x#0 >> us#0</exact>;
	<integer>x#0 <<< us#0</integer>;
	<integer>x#0 >>> us#0</integer>;
	<integer>x#0 + us#0</integer>;
	<integer>x#0 - us#0</integer>;
	<integer>x#0 * us#0</integer>;
	<integer>x#0 \ us#0</integer>;
	<exact>x#0 / us#0</exact>;
	<integer>x#0 % us#0</integer>;
	<half>x#0 & i#0</half>;
	<integer>x#0 | i#0</integer>;
	<integer>x#0 ^ i#0</integer>;
	<integer>x#0 << i#0</integer>;
	<exact>x#0 >> i#0</exact>;
	<integer>x#0 <<< i#0</integer>;
	<integer>x#0 >>> i#0</integer>;
	<integer>x#0 + i#0</integer>;
	<integer>x#0 - i#0</integer>;
	<integer>x#0 * i#0</integer>;
	<integer>x#0 \ i#0</integer>;
	<exact>x#0 / i#0</exact>;
	<integer>x#0 % i#0</integer>;
	<word>x#0 & ui#0</word>;
	<integer>x#0 | ui#0</integer>;
	<integer>x#0 ^ ui#0</integer>;
	<integer>x#0 << ui#0</integer>;
	<exact>x#0 >> ui#0</exact>;
	<integer>x#0 <<< ui#0</integer>;
	<integer>x#0 >>> ui#0</integer>;
	<integer>x#0 + ui#0</integer>;
	<integer>x#0 - ui#0</integer>;
	<integer>x#0 * ui#0</integer>;
	<integer>x#0 \ ui#0</integer>;
	<exact>x#0 / ui#0</exact>;
	<integer>x#0 % ui#0</integer>;
	<word>x#0 & l#0</word>;
	<integer>x#0 | l#0</integer>;
	<integer>x#0 ^ l#0</integer>;
	<integer>x#0 << l#0</integer>;
	<exact>x#0 >> l#0</exact>;
	<integer>x#0 <<< l#0</integer>;
	<integer>x#0 >>> l#0</integer>;
	<integer>x#0 + l#0</integer>;
	<integer>x#0 - l#0</integer>;
	<integer>x#0 * l#0</integer>;
	<integer>x#0 \ l#0</integer>;
	<exact>x#0 / l#0</exact>;
	<integer>x#0 % l#0</integer>;
	<integer>x#0 & ul#0</integer>;
	<integer>x#0 | ul#0</integer>;
	<integer>x#0 ^ ul#0</integer>;
	<integer>x#0 << ul#0</integer>;
	<exact>x#0 >> ul#0</exact>;
	<integer>x#0 <<< ul#0</integer>;
	<integer>x#0 >>> ul#0</integer>;
	<integer>x#0 + ul#0</integer>;
	<integer>x#0 - ul#0</integer>;
	<integer>x#0 * ul#0</integer>;
	<integer>x#0 \ ul#0</integer>;
	<exact>x#0 / ul#0</exact>;
	<integer>x#0 % ul#0</integer>;
	<integer>x#0 & f#0</integer>;
	<integer>x#0 | f#0</integer>;
	<integer>x#0 ^ f#0</integer>;
	<integer>x#0 << f#0</integer>;
	<exact>x#0 >> f#0</exact>;
	<integer>x#0 <<< f#0</integer>;
	<integer>x#0 >>> f#0</integer>;
	<single>x#0 + f#0</single>;
	<single>x#0 - f#0</single>;
	<single>x#0 * f#0</single>;
	<integer>x#0 \ f#0</integer>;
	<single>x#0 / f#0</single>;
	<single>x#0 % f#0</single>;
	<integer>x#0 & d#0</integer>;
	<integer>x#0 | d#0</integer>;
	<integer>x#0 ^ d#0</integer>;
	<integer>x#0 << d#0</integer>;
	<exact>x#0 >> d#0</exact>;
	<integer>x#0 <<< d#0</integer>;
	<integer>x#0 >>> d#0</integer>;
	<float>x#0 + d#0</float>;
	<float>x#0 - d#0</float>;
	<float>x#0 * d#0</float>;
	<integer>x#0 \ d#0</integer>;
	<float>x#0 / d#0</float>;
	<float>x#0 % d#0</float>;
	<integer>x#0 & v#0</integer>;
	<integer>x#0 | v#0</integer>;
	<integer>x#0 ^ v#0</integer>;
	<undef>x#0 << v#0</undef>;
	<undef>x#0 >> v#0</undef>;
	<integer>x#0 <<< v#0</integer>;
	<integer>x#0 >>> v#0</integer>;
	<undef>x#0 + v#0</undef>;
	<undef>x#0 - v#0</undef>;
	<undef>x#0 * v#0</undef>;
	<integer>x#0 \ v#0</integer>;
	<undef>x#0 / v#0</undef>;
	<real>x#0 % v#0</real>;
	<exact>x#0 + 1/2</exact>;
	<exact>x#0 - 1/2</exact>;
	<exact>x#0 * 1/2</exact>;
	<integer>x#0 \ 1/2</integer>;
	<exact>x#0 / 1/2</exact>;
	<exact>x#0 % 1/2</exact>;
	<integer>x#0 << 1.0l</integer>;
	<exact>x#0 >> 1.0l</exact>;
	<integer>x#0 <<< 1.0l</integer>;
	<integer>x#0 >>> 1.0l</integer>;
	<inexact>x#0 + 1.0l</inexact>;
	<inexact>x#0 - 1.0l</inexact>;
	<inexact>x#0 * 1.0l</inexact>;
	<integer>x#0 \ 1.0l</integer>;
	<inexact>x#0 / 1.0l</inexact>;
	<inexact>x#0 % 1.0l</inexact>;
    }
}"

test "void f(int8_t c, uint8_t uc, int16_t s, uint16_t us,
       int32_t i, uint32_t ui, int64_t l, uint64_t ul,
       float32_t f, float64_t d, auto v)
{
float32_t x;+x;-x;~x;
x&c;x|c;x^c;x<<c;x>>c;x<<<c;x>>>c;x+c;x-c;x*c;x\\c;x/c;x%c;
x&uc;x|uc;x^uc;x<<uc;x>>uc;x<<<uc;x>>>uc;x+uc;x-uc;x*uc;x\\uc;x/uc;x%uc;
x&s;x|s;x^s;x<<s;x>>s;x<<<s;x>>>s;x+s;x-s;x*s;x\\s;x/s;x%s;
x&us;x|us;x^us;x<<us;x>>us;x<<<us;x>>>us;x+us;x-us;x*us;x\\us;x/us;x%us;
x&i;x|i;x^i;x<<i;x>>i;x<<<i;x>>>i;x+i;x-i;x*i;x\\i;x/i;x%i;
x&ui;x|ui;x^ui;x<<ui;x>>ui;x<<<ui;x>>>ui;x+ui;x-ui;x*ui;x\\ui;x/ui;x%ui;
x&l;x|l;x^l;x<<l;x>>l;x<<<l;x>>>l;x+l;x-l;x*l;x\\l;x/l;x%l;
x&ul;x|ul;x^ul;x<<ul;x>>ul;x<<<ul;x>>>ul;x+ul;x-ul;x*ul;x\\ul;x/ul;x%ul;
x&f;x|f;x^f;x<<f;x>>f;x<<<f;x>>>f;x+f;x-f;x*f;x\\f;x/f;x%f;
x&d;x|d;x^d;x<<d;x>>d;x<<<d;x>>>d;x+d;x-d;x*d;x\\d;x/d;x%d;
x&v;x|v;x^v;x<<v;x>>v;x<<<v;x>>>v;x+v;x-v;x*v;x\\v;x/v;x%v;
x+(1/2);x-(1/2);x*(1/2);x\\(1/2);x/(1/2);x%(1/2);
x<<1L;x>>1L;x<<<1L;x>>>1L;x+1L;x-1L;x*1L;x\\1L;x/1L;x%1L;
}" "
void () {
    void f(int8_t c#0, uint8_t uc#0, int16_t s#0, uint16_t us#0, int32_t i#0, uint32_t ui#0, int64_t l#0, uint64_t ul#0, float32_t f#0, float64_t d#0, auto v#0) {
	float32_t x#0;
	<single>+x#0</single>;
	<single>-x#0</single>;
	<integer>~x#0</integer>;
	<half>x#0 & c#0</half>;
	<integer>x#0 | c#0</integer>;
	<integer>x#0 ^ c#0</integer>;
	<single>x#0 << c#0</single>;
	<single>x#0 >> c#0</single>;
	<integer>x#0 <<< c#0</integer>;
	<integer>x#0 >>> c#0</integer>;
	<single>x#0 + c#0</single>;
	<single>x#0 - c#0</single>;
	<single>x#0 * c#0</single>;
	<integer>x#0 \ c#0</integer>;
	<single>x#0 / c#0</single>;
	<single>x#0 % c#0</single>;
	<half>x#0 & uc#0</half>;
	<integer>x#0 | uc#0</integer>;
	<integer>x#0 ^ uc#0</integer>;
	<single>x#0 << uc#0</single>;
	<single>x#0 >> uc#0</single>;
	<integer>x#0 <<< uc#0</integer>;
	<integer>x#0 >>> uc#0</integer>;
	<single>x#0 + uc#0</single>;
	<single>x#0 - uc#0</single>;
	<single>x#0 * uc#0</single>;
	<integer>x#0 \ uc#0</integer>;
	<single>x#0 / uc#0</single>;
	<single>x#0 % uc#0</single>;
	<half>x#0 & s#0</half>;
	<integer>x#0 | s#0</integer>;
	<integer>x#0 ^ s#0</integer>;
	<single>x#0 << s#0</single>;
	<single>x#0 >> s#0</single>;
	<integer>x#0 <<< s#0</integer>;
	<integer>x#0 >>> s#0</integer>;
	<single>x#0 + s#0</single>;
	<single>x#0 - s#0</single>;
	<single>x#0 * s#0</single>;
	<integer>x#0 \ s#0</integer>;
	<single>x#0 / s#0</single>;
	<single>x#0 % s#0</single>;
	<half>x#0 & us#0</half>;
	<integer>x#0 | us#0</integer>;
	<integer>x#0 ^ us#0</integer>;
	<single>x#0 << us#0</single>;
	<single>x#0 >> us#0</single>;
	<integer>x#0 <<< us#0</integer>;
	<integer>x#0 >>> us#0</integer>;
	<single>x#0 + us#0</single>;
	<single>x#0 - us#0</single>;
	<single>x#0 * us#0</single>;
	<integer>x#0 \ us#0</integer>;
	<single>x#0 / us#0</single>;
	<single>x#0 % us#0</single>;
	<half>x#0 & i#0</half>;
	<integer>x#0 | i#0</integer>;
	<integer>x#0 ^ i#0</integer>;
	<single>x#0 << i#0</single>;
	<single>x#0 >> i#0</single>;
	<integer>x#0 <<< i#0</integer>;
	<integer>x#0 >>> i#0</integer>;
	<single>x#0 + i#0</single>;
	<single>x#0 - i#0</single>;
	<single>x#0 * i#0</single>;
	<integer>x#0 \ i#0</integer>;
	<single>x#0 / i#0</single>;
	<single>x#0 % i#0</single>;
	<word>x#0 & ui#0</word>;
	<integer>x#0 | ui#0</integer>;
	<integer>x#0 ^ ui#0</integer>;
	<single>x#0 << ui#0</single>;
	<single>x#0 >> ui#0</single>;
	<integer>x#0 <<< ui#0</integer>;
	<integer>x#0 >>> ui#0</integer>;
	<single>x#0 + ui#0</single>;
	<single>x#0 - ui#0</single>;
	<single>x#0 * ui#0</single>;
	<integer>x#0 \ ui#0</integer>;
	<single>x#0 / ui#0</single>;
	<single>x#0 % ui#0</single>;
	<word>x#0 & l#0</word>;
	<integer>x#0 | l#0</integer>;
	<integer>x#0 ^ l#0</integer>;
	<single>x#0 << l#0</single>;
	<single>x#0 >> l#0</single>;
	<integer>x#0 <<< l#0</integer>;
	<integer>x#0 >>> l#0</integer>;
	<single>x#0 + l#0</single>;
	<single>x#0 - l#0</single>;
	<single>x#0 * l#0</single>;
	<integer>x#0 \ l#0</integer>;
	<single>x#0 / l#0</single>;
	<single>x#0 % l#0</single>;
	<integer>x#0 & ul#0</integer>;
	<integer>x#0 | ul#0</integer>;
	<integer>x#0 ^ ul#0</integer>;
	<single>x#0 << ul#0</single>;
	<single>x#0 >> ul#0</single>;
	<integer>x#0 <<< ul#0</integer>;
	<integer>x#0 >>> ul#0</integer>;
	<single>x#0 + ul#0</single>;
	<single>x#0 - ul#0</single>;
	<single>x#0 * ul#0</single>;
	<integer>x#0 \ ul#0</integer>;
	<single>x#0 / ul#0</single>;
	<single>x#0 % ul#0</single>;
	<integer>x#0 & f#0</integer>;
	<integer>x#0 | f#0</integer>;
	<integer>x#0 ^ f#0</integer>;
	<single>x#0 << f#0</single>;
	<single>x#0 >> f#0</single>;
	<integer>x#0 <<< f#0</integer>;
	<integer>x#0 >>> f#0</integer>;
	<single>x#0 + f#0</single>;
	<single>x#0 - f#0</single>;
	<single>x#0 * f#0</single>;
	<integer>x#0 \ f#0</integer>;
	<single>x#0 / f#0</single>;
	<single>x#0 % f#0</single>;
	<integer>x#0 & d#0</integer>;
	<integer>x#0 | d#0</integer>;
	<integer>x#0 ^ d#0</integer>;
	<single>x#0 << d#0</single>;
	<single>x#0 >> d#0</single>;
	<integer>x#0 <<< d#0</integer>;
	<integer>x#0 >>> d#0</integer>;
	<float>x#0 + d#0</float>;
	<float>x#0 - d#0</float>;
	<float>x#0 * d#0</float>;
	<integer>x#0 \ d#0</integer>;
	<float>x#0 / d#0</float>;
	<float>x#0 % d#0</float>;
	<integer>x#0 & v#0</integer>;
	<integer>x#0 | v#0</integer>;
	<integer>x#0 ^ v#0</integer>;
	<undef>x#0 << v#0</undef>;
	<undef>x#0 >> v#0</undef>;
	<integer>x#0 <<< v#0</integer>;
	<integer>x#0 >>> v#0</integer>;
	<undef>x#0 + v#0</undef>;
	<undef>x#0 - v#0</undef>;
	<undef>x#0 * v#0</undef>;
	<integer>x#0 \ v#0</integer>;
	<undef>x#0 / v#0</undef>;
	<real>x#0 % v#0</real>;
	<single>x#0 + 1/2</single>;
	<single>x#0 - 1/2</single>;
	<single>x#0 * 1/2</single>;
	<integer>x#0 \ 1/2</integer>;
	<single>x#0 / 1/2</single>;
	<single>x#0 % 1/2</single>;
	<single>x#0 << 1.0l</single>;
	<single>x#0 >> 1.0l</single>;
	<integer>x#0 <<< 1.0l</integer>;
	<integer>x#0 >>> 1.0l</integer>;
	<inexact>x#0 + 1.0l</inexact>;
	<inexact>x#0 - 1.0l</inexact>;
	<inexact>x#0 * 1.0l</inexact>;
	<integer>x#0 \ 1.0l</integer>;
	<inexact>x#0 / 1.0l</inexact>;
	<inexact>x#0 % 1.0l</inexact>;
    }
}"

test "void f(int8_t c, uint8_t uc, int16_t s, uint16_t us,
       int32_t i, uint32_t ui, int64_t l, uint64_t ul,
       float32_t f, float64_t d, auto v)
{
float64_t x;+x;-x;~x;
x&c;x|c;x^c;x<<c;x>>c;x<<<c;x>>>c;x+c;x-c;x*c;x\\c;x/c;x%c;
x&uc;x|uc;x^uc;x<<uc;x>>uc;x<<<uc;x>>>uc;x+uc;x-uc;x*uc;x\\uc;x/uc;x%uc;
x&s;x|s;x^s;x<<s;x>>s;x<<<s;x>>>s;x+s;x-s;x*s;x\\s;x/s;x%s;
x&us;x|us;x^us;x<<us;x>>us;x<<<us;x>>>us;x+us;x-us;x*us;x\\us;x/us;x%us;
x&i;x|i;x^i;x<<i;x>>i;x<<<i;x>>>i;x+i;x-i;x*i;x\\i;x/i;x%i;
x&ui;x|ui;x^ui;x<<ui;x>>ui;x<<<ui;x>>>ui;x+ui;x-ui;x*ui;x\\ui;x/ui;x%ui;
x&l;x|l;x^l;x<<l;x>>l;x<<<l;x>>>l;x+l;x-l;x*l;x\\l;x/l;x%l;
x&ul;x|ul;x^ul;x<<ul;x>>ul;x<<<ul;x>>>ul;x+ul;x-ul;x*ul;x\\ul;x/ul;x%ul;
x&f;x|f;x^f;x<<f;x>>f;x<<<f;x>>>f;x+f;x-f;x*f;x\\f;x/f;x%f;
x&d;x|d;x^d;x<<d;x>>d;x<<<d;x>>>d;x+d;x-d;x*d;x\\d;x/d;x%d;
x&v;x|v;x^v;x<<v;x>>v;x<<<v;x>>>v;x+v;x-v;x*v;x\\v;x/v;x%v;
x+(1/2);x-(1/2);x*(1/2);x\\(1/2);x/(1/2);x%(1/2);
x<<1L;x>>1L;x<<<1L;x>>>1L;x+1L;x-1L;x*1L;x\\1L;x/1L;x%1L;
}" "
void () {
    void f(int8_t c#0, uint8_t uc#0, int16_t s#0, uint16_t us#0, int32_t i#0, uint32_t ui#0, int64_t l#0, uint64_t ul#0, float32_t f#0, float64_t d#0, auto v#0) {
	float64_t x#0;
	<float>+x#0</float>;
	<float>-x#0</float>;
	<integer>~x#0</integer>;
	<half>x#0 & c#0</half>;
	<integer>x#0 | c#0</integer>;
	<integer>x#0 ^ c#0</integer>;
	<float>x#0 << c#0</float>;
	<float>x#0 >> c#0</float>;
	<integer>x#0 <<< c#0</integer>;
	<integer>x#0 >>> c#0</integer>;
	<float>x#0 + c#0</float>;
	<float>x#0 - c#0</float>;
	<float>x#0 * c#0</float>;
	<integer>x#0 \ c#0</integer>;
	<float>x#0 / c#0</float>;
	<float>x#0 % c#0</float>;
	<half>x#0 & uc#0</half>;
	<integer>x#0 | uc#0</integer>;
	<integer>x#0 ^ uc#0</integer>;
	<float>x#0 << uc#0</float>;
	<float>x#0 >> uc#0</float>;
	<integer>x#0 <<< uc#0</integer>;
	<integer>x#0 >>> uc#0</integer>;
	<float>x#0 + uc#0</float>;
	<float>x#0 - uc#0</float>;
	<float>x#0 * uc#0</float>;
	<integer>x#0 \ uc#0</integer>;
	<float>x#0 / uc#0</float>;
	<float>x#0 % uc#0</float>;
	<half>x#0 & s#0</half>;
	<integer>x#0 | s#0</integer>;
	<integer>x#0 ^ s#0</integer>;
	<float>x#0 << s#0</float>;
	<float>x#0 >> s#0</float>;
	<integer>x#0 <<< s#0</integer>;
	<integer>x#0 >>> s#0</integer>;
	<float>x#0 + s#0</float>;
	<float>x#0 - s#0</float>;
	<float>x#0 * s#0</float>;
	<integer>x#0 \ s#0</integer>;
	<float>x#0 / s#0</float>;
	<float>x#0 % s#0</float>;
	<half>x#0 & us#0</half>;
	<integer>x#0 | us#0</integer>;
	<integer>x#0 ^ us#0</integer>;
	<float>x#0 << us#0</float>;
	<float>x#0 >> us#0</float>;
	<integer>x#0 <<< us#0</integer>;
	<integer>x#0 >>> us#0</integer>;
	<float>x#0 + us#0</float>;
	<float>x#0 - us#0</float>;
	<float>x#0 * us#0</float>;
	<integer>x#0 \ us#0</integer>;
	<float>x#0 / us#0</float>;
	<float>x#0 % us#0</float>;
	<half>x#0 & i#0</half>;
	<integer>x#0 | i#0</integer>;
	<integer>x#0 ^ i#0</integer>;
	<float>x#0 << i#0</float>;
	<float>x#0 >> i#0</float>;
	<integer>x#0 <<< i#0</integer>;
	<integer>x#0 >>> i#0</integer>;
	<float>x#0 + i#0</float>;
	<float>x#0 - i#0</float>;
	<float>x#0 * i#0</float>;
	<integer>x#0 \ i#0</integer>;
	<float>x#0 / i#0</float>;
	<float>x#0 % i#0</float>;
	<word>x#0 & ui#0</word>;
	<integer>x#0 | ui#0</integer>;
	<integer>x#0 ^ ui#0</integer>;
	<float>x#0 << ui#0</float>;
	<float>x#0 >> ui#0</float>;
	<integer>x#0 <<< ui#0</integer>;
	<integer>x#0 >>> ui#0</integer>;
	<float>x#0 + ui#0</float>;
	<float>x#0 - ui#0</float>;
	<float>x#0 * ui#0</float>;
	<integer>x#0 \ ui#0</integer>;
	<float>x#0 / ui#0</float>;
	<float>x#0 % ui#0</float>;
	<word>x#0 & l#0</word>;
	<integer>x#0 | l#0</integer>;
	<integer>x#0 ^ l#0</integer>;
	<float>x#0 << l#0</float>;
	<float>x#0 >> l#0</float>;
	<integer>x#0 <<< l#0</integer>;
	<integer>x#0 >>> l#0</integer>;
	<float>x#0 + l#0</float>;
	<float>x#0 - l#0</float>;
	<float>x#0 * l#0</float>;
	<integer>x#0 \ l#0</integer>;
	<float>x#0 / l#0</float>;
	<float>x#0 % l#0</float>;
	<integer>x#0 & ul#0</integer>;
	<integer>x#0 | ul#0</integer>;
	<integer>x#0 ^ ul#0</integer>;
	<float>x#0 << ul#0</float>;
	<float>x#0 >> ul#0</float>;
	<integer>x#0 <<< ul#0</integer>;
	<integer>x#0 >>> ul#0</integer>;
	<float>x#0 + ul#0</float>;
	<float>x#0 - ul#0</float>;
	<float>x#0 * ul#0</float>;
	<integer>x#0 \ ul#0</integer>;
	<float>x#0 / ul#0</float>;
	<float>x#0 % ul#0</float>;
	<integer>x#0 & f#0</integer>;
	<integer>x#0 | f#0</integer>;
	<integer>x#0 ^ f#0</integer>;
	<float>x#0 << f#0</float>;
	<float>x#0 >> f#0</float>;
	<integer>x#0 <<< f#0</integer>;
	<integer>x#0 >>> f#0</integer>;
	<float>x#0 + f#0</float>;
	<float>x#0 - f#0</float>;
	<float>x#0 * f#0</float>;
	<integer>x#0 \ f#0</integer>;
	<float>x#0 / f#0</float>;
	<float>x#0 % f#0</float>;
	<integer>x#0 & d#0</integer>;
	<integer>x#0 | d#0</integer>;
	<integer>x#0 ^ d#0</integer>;
	<float>x#0 << d#0</float>;
	<float>x#0 >> d#0</float>;
	<integer>x#0 <<< d#0</integer>;
	<integer>x#0 >>> d#0</integer>;
	<float>x#0 + d#0</float>;
	<float>x#0 - d#0</float>;
	<float>x#0 * d#0</float>;
	<integer>x#0 \ d#0</integer>;
	<float>x#0 / d#0</float>;
	<float>x#0 % d#0</float>;
	<integer>x#0 & v#0</integer>;
	<integer>x#0 | v#0</integer>;
	<integer>x#0 ^ v#0</integer>;
	<undef>x#0 << v#0</undef>;
	<undef>x#0 >> v#0</undef>;
	<integer>x#0 <<< v#0</integer>;
	<integer>x#0 >>> v#0</integer>;
	<undef>x#0 + v#0</undef>;
	<undef>x#0 - v#0</undef>;
	<undef>x#0 * v#0</undef>;
	<integer>x#0 \ v#0</integer>;
	<undef>x#0 / v#0</undef>;
	<real>x#0 % v#0</real>;
	<float>x#0 + 1/2</float>;
	<float>x#0 - 1/2</float>;
	<float>x#0 * 1/2</float>;
	<integer>x#0 \ 1/2</integer>;
	<float>x#0 / 1/2</float>;
	<float>x#0 % 1/2</float>;
	<float>x#0 << 1.0l</float>;
	<float>x#0 >> 1.0l</float>;
	<integer>x#0 <<< 1.0l</integer>;
	<integer>x#0 >>> 1.0l</integer>;
	<inexact>x#0 + 1.0l</inexact>;
	<inexact>x#0 - 1.0l</inexact>;
	<inexact>x#0 * 1.0l</inexact>;
	<integer>x#0 \ 1.0l</integer>;
	<inexact>x#0 / 1.0l</inexact>;
	<inexact>x#0 % 1.0l</inexact>;
    }
}"

test "void f(int8_t c, uint8_t uc, int16_t s, uint16_t us,
       int32_t i, uint32_t ui, int64_t l, uint64_t ul,
       float32_t f, float64_t d, auto v)
{
auto x;+x;-x;~x;
x&c;x|c;x^c;x<<c;x>>c;x<<<c;x>>>c;x+c;x-c;x*c;x\\c;x/c;x%c;
x&uc;x|uc;x^uc;x<<uc;x>>uc;x<<<uc;x>>>uc;x+uc;x-uc;x*uc;x\\uc;x/uc;x%uc;
x&s;x|s;x^s;x<<s;x>>s;x<<<s;x>>>s;x+s;x-s;x*s;x\\s;x/s;x%s;
x&us;x|us;x^us;x<<us;x>>us;x<<<us;x>>>us;x+us;x-us;x*us;x\\us;x/us;x%us;
x&i;x|i;x^i;x<<i;x>>i;x<<<i;x>>>i;x+i;x-i;x*i;x\\i;x/i;x%i;
x&ui;x|ui;x^ui;x<<ui;x>>ui;x<<<ui;x>>>ui;x+ui;x-ui;x*ui;x\\ui;x/ui;x%ui;
x&l;x|l;x^l;x<<l;x>>l;x<<<l;x>>>l;x+l;x-l;x*l;x\\l;x/l;x%l;
x&ul;x|ul;x^ul;x<<ul;x>>ul;x<<<ul;x>>>ul;x+ul;x-ul;x*ul;x\\ul;x/ul;x%ul;
x&f;x|f;x^f;x<<f;x>>f;x<<<f;x>>>f;x+f;x-f;x*f;x\\f;x/f;x%f;
x&d;x|d;x^d;x<<d;x>>d;x<<<d;x>>>d;x+d;x-d;x*d;x\\d;x/d;x%d;
x&v;x|v;x^v;x<<v;x>>v;x<<<v;x>>>v;x+v;x-v;x*v;x\\v;x/v;x%v;
x+(1/2);x-(1/2);x*(1/2);x\\(1/2);x/(1/2);x%(1/2);
x<<1L;x>>1L;x<<<1L;x>>>1L;x+1L;x-1L;x*1L;x\\1L;x/1L;x%1L;
}" "
void () {
    void f(int8_t c#0, uint8_t uc#0, int16_t s#0, uint16_t us#0, int32_t i#0, uint32_t ui#0, int64_t l#0, uint64_t ul#0, float32_t f#0, float64_t d#0, auto v#0) {
	auto x#0;
	<undef>+x#0</undef>;
	<undef>-x#0</undef>;
	<integer>~x#0</integer>;
	<half>x#0 & c#0</half>;
	<integer>x#0 | c#0</integer>;
	<integer>x#0 ^ c#0</integer>;
	<undef>x#0 << c#0</undef>;
	<undef>x#0 >> c#0</undef>;
	<integer>x#0 <<< c#0</integer>;
	<integer>x#0 >>> c#0</integer>;
	<undef>x#0 + c#0</undef>;
	<undef>x#0 - c#0</undef>;
	<undef>x#0 * c#0</undef>;
	<integer>x#0 \ c#0</integer>;
	<undef>x#0 / c#0</undef>;
	<real>x#0 % c#0</real>;
	<half>x#0 & uc#0</half>;
	<integer>x#0 | uc#0</integer>;
	<integer>x#0 ^ uc#0</integer>;
	<undef>x#0 << uc#0</undef>;
	<undef>x#0 >> uc#0</undef>;
	<integer>x#0 <<< uc#0</integer>;
	<integer>x#0 >>> uc#0</integer>;
	<undef>x#0 + uc#0</undef>;
	<undef>x#0 - uc#0</undef>;
	<undef>x#0 * uc#0</undef>;
	<integer>x#0 \ uc#0</integer>;
	<undef>x#0 / uc#0</undef>;
	<real>x#0 % uc#0</real>;
	<half>x#0 & s#0</half>;
	<integer>x#0 | s#0</integer>;
	<integer>x#0 ^ s#0</integer>;
	<undef>x#0 << s#0</undef>;
	<undef>x#0 >> s#0</undef>;
	<integer>x#0 <<< s#0</integer>;
	<integer>x#0 >>> s#0</integer>;
	<undef>x#0 + s#0</undef>;
	<undef>x#0 - s#0</undef>;
	<undef>x#0 * s#0</undef>;
	<integer>x#0 \ s#0</integer>;
	<undef>x#0 / s#0</undef>;
	<real>x#0 % s#0</real>;
	<half>x#0 & us#0</half>;
	<integer>x#0 | us#0</integer>;
	<integer>x#0 ^ us#0</integer>;
	<undef>x#0 << us#0</undef>;
	<undef>x#0 >> us#0</undef>;
	<integer>x#0 <<< us#0</integer>;
	<integer>x#0 >>> us#0</integer>;
	<undef>x#0 + us#0</undef>;
	<undef>x#0 - us#0</undef>;
	<undef>x#0 * us#0</undef>;
	<integer>x#0 \ us#0</integer>;
	<undef>x#0 / us#0</undef>;
	<real>x#0 % us#0</real>;
	<half>x#0 & i#0</half>;
	<integer>x#0 | i#0</integer>;
	<integer>x#0 ^ i#0</integer>;
	<undef>x#0 << i#0</undef>;
	<undef>x#0 >> i#0</undef>;
	<integer>x#0 <<< i#0</integer>;
	<integer>x#0 >>> i#0</integer>;
	<undef>x#0 + i#0</undef>;
	<undef>x#0 - i#0</undef>;
	<undef>x#0 * i#0</undef>;
	<integer>x#0 \ i#0</integer>;
	<undef>x#0 / i#0</undef>;
	<real>x#0 % i#0</real>;
	<word>x#0 & ui#0</word>;
	<integer>x#0 | ui#0</integer>;
	<integer>x#0 ^ ui#0</integer>;
	<undef>x#0 << ui#0</undef>;
	<undef>x#0 >> ui#0</undef>;
	<integer>x#0 <<< ui#0</integer>;
	<integer>x#0 >>> ui#0</integer>;
	<undef>x#0 + ui#0</undef>;
	<undef>x#0 - ui#0</undef>;
	<undef>x#0 * ui#0</undef>;
	<integer>x#0 \ ui#0</integer>;
	<undef>x#0 / ui#0</undef>;
	<real>x#0 % ui#0</real>;
	<word>x#0 & l#0</word>;
	<integer>x#0 | l#0</integer>;
	<integer>x#0 ^ l#0</integer>;
	<undef>x#0 << l#0</undef>;
	<undef>x#0 >> l#0</undef>;
	<integer>x#0 <<< l#0</integer>;
	<integer>x#0 >>> l#0</integer>;
	<undef>x#0 + l#0</undef>;
	<undef>x#0 - l#0</undef>;
	<undef>x#0 * l#0</undef>;
	<integer>x#0 \ l#0</integer>;
	<undef>x#0 / l#0</undef>;
	<real>x#0 % l#0</real>;
	<integer>x#0 & ul#0</integer>;
	<integer>x#0 | ul#0</integer>;
	<integer>x#0 ^ ul#0</integer>;
	<undef>x#0 << ul#0</undef>;
	<undef>x#0 >> ul#0</undef>;
	<integer>x#0 <<< ul#0</integer>;
	<integer>x#0 >>> ul#0</integer>;
	<undef>x#0 + ul#0</undef>;
	<undef>x#0 - ul#0</undef>;
	<undef>x#0 * ul#0</undef>;
	<integer>x#0 \ ul#0</integer>;
	<undef>x#0 / ul#0</undef>;
	<real>x#0 % ul#0</real>;
	<integer>x#0 & f#0</integer>;
	<integer>x#0 | f#0</integer>;
	<integer>x#0 ^ f#0</integer>;
	<undef>x#0 << f#0</undef>;
	<undef>x#0 >> f#0</undef>;
	<integer>x#0 <<< f#0</integer>;
	<integer>x#0 >>> f#0</integer>;
	<undef>x#0 + f#0</undef>;
	<undef>x#0 - f#0</undef>;
	<undef>x#0 * f#0</undef>;
	<integer>x#0 \ f#0</integer>;
	<undef>x#0 / f#0</undef>;
	<real>x#0 % f#0</real>;
	<integer>x#0 & d#0</integer>;
	<integer>x#0 | d#0</integer>;
	<integer>x#0 ^ d#0</integer>;
	<undef>x#0 << d#0</undef>;
	<undef>x#0 >> d#0</undef>;
	<integer>x#0 <<< d#0</integer>;
	<integer>x#0 >>> d#0</integer>;
	<undef>x#0 + d#0</undef>;
	<undef>x#0 - d#0</undef>;
	<undef>x#0 * d#0</undef>;
	<integer>x#0 \ d#0</integer>;
	<undef>x#0 / d#0</undef>;
	<real>x#0 % d#0</real>;
	<integer>x#0 & v#0</integer>;
	<integer>x#0 | v#0</integer>;
	<integer>x#0 ^ v#0</integer>;
	<undef>x#0 << v#0</undef>;
	<undef>x#0 >> v#0</undef>;
	<integer>x#0 <<< v#0</integer>;
	<integer>x#0 >>> v#0</integer>;
	<undef>x#0 + v#0</undef>;
	<undef>x#0 - v#0</undef>;
	<undef>x#0 * v#0</undef>;
	<integer>x#0 \ v#0</integer>;
	<undef>x#0 / v#0</undef>;
	<real>x#0 % v#0</real>;
	<undef>x#0 + 1/2</undef>;
	<undef>x#0 - 1/2</undef>;
	<undef>x#0 * 1/2</undef>;
	<integer>x#0 \ 1/2</integer>;
	<undef>x#0 / 1/2</undef>;
	<real>x#0 % 1/2</real>;
	<undef>x#0 << 1.0l</undef>;
	<undef>x#0 >> 1.0l</undef>;
	<integer>x#0 <<< 1.0l</integer>;
	<integer>x#0 >>> 1.0l</integer>;
	<undef>x#0 + 1.0l</undef>;
	<undef>x#0 - 1.0l</undef>;
	<undef>x#0 * 1.0l</undef>;
	<integer>x#0 \ 1.0l</integer>;
	<undef>x#0 / 1.0l</undef>;
	<real>x#0 % 1.0l</real>;
    }
}"

test "void f(int8_t c, uint8_t uc, int16_t s, uint16_t us,
       int32_t i, uint32_t ui, int64_t l, uint64_t ul,
       float32_t f, float64_t d, auto v)
{
(1/2)<<c;(1/2)>>c;(1/2)<<<c;(1/2)>>>c;(1/2)+c;(1/2)-c;(1/2)*c;(1/2)\\c;(1/2)/c;(1/2)%c;
(1/2)<<uc;(1/2)>>uc;(1/2)<<<uc;(1/2)>>>uc;(1/2)+uc;(1/2)-uc;(1/2)*uc;(1/2)\\uc;(1/2)/uc;(1/2)%uc;
(1/2)<<s;(1/2)>>s;(1/2)<<<s;(1/2)>>>s;(1/2)+s;(1/2)-s;(1/2)*s;(1/2)\\s;(1/2)/s;(1/2)%s;
(1/2)<<us;(1/2)>>us;(1/2)<<<us;(1/2)>>>us;(1/2)+us;(1/2)-us;(1/2)*us;(1/2)\\us;(1/2)/us;(1/2)%us;
(1/2)<<i;(1/2)>>i;(1/2)<<<i;(1/2)>>>i;(1/2)+i;(1/2)-i;(1/2)*i;(1/2)\\i;(1/2)/i;(1/2)%i;
(1/2)<<ui;(1/2)>>ui;(1/2)<<<ui;(1/2)>>>ui;(1/2)+ui;(1/2)-ui;(1/2)*ui;(1/2)\\ui;(1/2)/ui;(1/2)%ui;
(1/2)<<l;(1/2)>>l;(1/2)<<<l;(1/2)>>>l;(1/2)+l;(1/2)-l;(1/2)*l;(1/2)\\l;(1/2)/l;(1/2)%l;
(1/2)<<ul;(1/2)>>ul;(1/2)<<<ul;(1/2)>>>ul;(1/2)+ul;(1/2)-ul;(1/2)*ul;(1/2)\\ul;(1/2)/ul;(1/2)%ul;
(1/2)<<f;(1/2)>>f;(1/2)<<<f;(1/2)>>>f;(1/2)+f;(1/2)-f;(1/2)*f;(1/2)\\f;(1/2)/f;(1/2)%f;
(1/2)<<d;(1/2)>>d;(1/2)<<<d;(1/2)>>>d;(1/2)+d;(1/2)-d;(1/2)*d;(1/2)\\d;(1/2)/d;(1/2)%d;
(1/2)<<v;(1/2)>>v;(1/2)<<<v;(1/2)>>>v;(1/2)+v;(1/2)-v;(1/2)*v;(1/2)\\v;(1/2)/v;(1/2)%v;
}" "
void () {
    void f(int8_t c#0, uint8_t uc#0, int16_t s#0, uint16_t us#0, int32_t i#0, uint32_t ui#0, int64_t l#0, uint64_t ul#0, float32_t f#0, float64_t d#0, auto v#0) {
	<exact>1/2 << c#0</exact>;
	<exact>1/2 >> c#0</exact>;
	<integer>1/2 <<< c#0</integer>;
	<integer>1/2 >>> c#0</integer>;
	<exact>1/2 + c#0</exact>;
	<exact>1/2 - c#0</exact>;
	<exact>1/2 * c#0</exact>;
	<integer>1/2 \ c#0</integer>;
	<exact>1/2 / c#0</exact>;
	<exact>1/2 % c#0</exact>;
	<exact>1/2 << uc#0</exact>;
	<exact>1/2 >> uc#0</exact>;
	<integer>1/2 <<< uc#0</integer>;
	<integer>1/2 >>> uc#0</integer>;
	<exact>1/2 + uc#0</exact>;
	<exact>1/2 - uc#0</exact>;
	<exact>1/2 * uc#0</exact>;
	<integer>1/2 \ uc#0</integer>;
	<exact>1/2 / uc#0</exact>;
	<exact>1/2 % uc#0</exact>;
	<exact>1/2 << s#0</exact>;
	<exact>1/2 >> s#0</exact>;
	<integer>1/2 <<< s#0</integer>;
	<integer>1/2 >>> s#0</integer>;
	<exact>1/2 + s#0</exact>;
	<exact>1/2 - s#0</exact>;
	<exact>1/2 * s#0</exact>;
	<integer>1/2 \ s#0</integer>;
	<exact>1/2 / s#0</exact>;
	<exact>1/2 % s#0</exact>;
	<exact>1/2 << us#0</exact>;
	<exact>1/2 >> us#0</exact>;
	<integer>1/2 <<< us#0</integer>;
	<integer>1/2 >>> us#0</integer>;
	<exact>1/2 + us#0</exact>;
	<exact>1/2 - us#0</exact>;
	<exact>1/2 * us#0</exact>;
	<integer>1/2 \ us#0</integer>;
	<exact>1/2 / us#0</exact>;
	<exact>1/2 % us#0</exact>;
	<exact>1/2 << i#0</exact>;
	<exact>1/2 >> i#0</exact>;
	<integer>1/2 <<< i#0</integer>;
	<integer>1/2 >>> i#0</integer>;
	<exact>1/2 + i#0</exact>;
	<exact>1/2 - i#0</exact>;
	<exact>1/2 * i#0</exact>;
	<integer>1/2 \ i#0</integer>;
	<exact>1/2 / i#0</exact>;
	<exact>1/2 % i#0</exact>;
	<exact>1/2 << ui#0</exact>;
	<exact>1/2 >> ui#0</exact>;
	<integer>1/2 <<< ui#0</integer>;
	<integer>1/2 >>> ui#0</integer>;
	<exact>1/2 + ui#0</exact>;
	<exact>1/2 - ui#0</exact>;
	<exact>1/2 * ui#0</exact>;
	<integer>1/2 \ ui#0</integer>;
	<exact>1/2 / ui#0</exact>;
	<exact>1/2 % ui#0</exact>;
	<exact>1/2 << l#0</exact>;
	<exact>1/2 >> l#0</exact>;
	<integer>1/2 <<< l#0</integer>;
	<integer>1/2 >>> l#0</integer>;
	<exact>1/2 + l#0</exact>;
	<exact>1/2 - l#0</exact>;
	<exact>1/2 * l#0</exact>;
	<integer>1/2 \ l#0</integer>;
	<exact>1/2 / l#0</exact>;
	<exact>1/2 % l#0</exact>;
	<exact>1/2 << ul#0</exact>;
	<exact>1/2 >> ul#0</exact>;
	<integer>1/2 <<< ul#0</integer>;
	<integer>1/2 >>> ul#0</integer>;
	<exact>1/2 + ul#0</exact>;
	<exact>1/2 - ul#0</exact>;
	<exact>1/2 * ul#0</exact>;
	<integer>1/2 \ ul#0</integer>;
	<exact>1/2 / ul#0</exact>;
	<exact>1/2 % ul#0</exact>;
	<exact>1/2 << f#0</exact>;
	<exact>1/2 >> f#0</exact>;
	<integer>1/2 <<< f#0</integer>;
	<integer>1/2 >>> f#0</integer>;
	<single>1/2 + f#0</single>;
	<single>1/2 - f#0</single>;
	<single>1/2 * f#0</single>;
	<integer>1/2 \ f#0</integer>;
	<single>1/2 / f#0</single>;
	<single>1/2 % f#0</single>;
	<exact>1/2 << d#0</exact>;
	<exact>1/2 >> d#0</exact>;
	<integer>1/2 <<< d#0</integer>;
	<integer>1/2 >>> d#0</integer>;
	<float>1/2 + d#0</float>;
	<float>1/2 - d#0</float>;
	<float>1/2 * d#0</float>;
	<integer>1/2 \ d#0</integer>;
	<float>1/2 / d#0</float>;
	<float>1/2 % d#0</float>;
	<undef>1/2 << v#0</undef>;
	<undef>1/2 >> v#0</undef>;
	<integer>1/2 <<< v#0</integer>;
	<integer>1/2 >>> v#0</integer>;
	<undef>1/2 + v#0</undef>;
	<undef>1/2 - v#0</undef>;
	<undef>1/2 * v#0</undef>;
	<integer>1/2 \ v#0</integer>;
	<undef>1/2 / v#0</undef>;
	<real>1/2 % v#0</real>;
    }
}"

test "void f(int8_t c, uint8_t uc, int16_t s, uint16_t us,
       int32_t i, uint32_t ui, int64_t l, uint64_t ul,
       float32_t f, float64_t d, auto v)
{
1L<<c;1L>>c;1L<<<c;1L>>>c;1L+c;1L-c;1L*c;1L\\c;1L/c;1L%c;
1L<<uc;1L>>uc;1L<<<uc;1L>>>uc;1L+uc;1L-uc;1L*uc;1L\\uc;1L/uc;1L%uc;
1L<<s;1L>>s;1L<<<s;1L>>>s;1L+s;1L-s;1L*s;1L\\s;1L/s;1L%s;
1L<<us;1L>>us;1L<<<us;1L>>>us;1L+us;1L-us;1L*us;1L\\us;1L/us;1L%us;
1L<<i;1L>>i;1L<<<i;1L>>>i;1L+i;1L-i;1L*i;1L\\i;1L/i;1L%i;
1L<<ui;1L>>ui;1L<<<ui;1L>>>ui;1L+ui;1L-ui;1L*ui;1L\\ui;1L/ui;1L%ui;
1L<<l;1L>>l;1L<<<l;1L>>>l;1L+l;1L-l;1L*l;1L\\l;1L/l;1L%l;
1L<<ul;1L>>ul;1L<<<ul;1L>>>ul;1L+ul;1L-ul;1L*ul;1L\\ul;1L/ul;1L%ul;
1L<<f;1L>>f;1L<<<f;1L>>>f;1L+f;1L-f;1L*f;1L\\f;1L/f;1L%f;
1L<<d;1L>>d;1L<<<d;1L>>>d;1L+d;1L-d;1L*d;1L\\d;1L/d;1L%d;
1L<<v;1L>>v;1L<<<v;1L>>>v;1L+v;1L-v;1L*v;1L\\v;1L/v;1L%v;
}" "
void () {
    void f(int8_t c#0, uint8_t uc#0, int16_t s#0, uint16_t us#0, int32_t i#0, uint32_t ui#0, int64_t l#0, uint64_t ul#0, float32_t f#0, float64_t d#0, auto v#0) {
	<inexact>1.0l << c#0</inexact>;
	<inexact>1.0l >> c#0</inexact>;
	<integer>1.0l <<< c#0</integer>;
	<integer>1.0l >>> c#0</integer>;
	<inexact>1.0l + c#0</inexact>;
	<inexact>1.0l - c#0</inexact>;
	<inexact>1.0l * c#0</inexact>;
	<integer>1.0l \ c#0</integer>;
	<inexact>1.0l / c#0</inexact>;
	<inexact>1.0l % c#0</inexact>;
	<inexact>1.0l << uc#0</inexact>;
	<inexact>1.0l >> uc#0</inexact>;
	<integer>1.0l <<< uc#0</integer>;
	<integer>1.0l >>> uc#0</integer>;
	<inexact>1.0l + uc#0</inexact>;
	<inexact>1.0l - uc#0</inexact>;
	<inexact>1.0l * uc#0</inexact>;
	<integer>1.0l \ uc#0</integer>;
	<inexact>1.0l / uc#0</inexact>;
	<inexact>1.0l % uc#0</inexact>;
	<inexact>1.0l << s#0</inexact>;
	<inexact>1.0l >> s#0</inexact>;
	<integer>1.0l <<< s#0</integer>;
	<integer>1.0l >>> s#0</integer>;
	<inexact>1.0l + s#0</inexact>;
	<inexact>1.0l - s#0</inexact>;
	<inexact>1.0l * s#0</inexact>;
	<integer>1.0l \ s#0</integer>;
	<inexact>1.0l / s#0</inexact>;
	<inexact>1.0l % s#0</inexact>;
	<inexact>1.0l << us#0</inexact>;
	<inexact>1.0l >> us#0</inexact>;
	<integer>1.0l <<< us#0</integer>;
	<integer>1.0l >>> us#0</integer>;
	<inexact>1.0l + us#0</inexact>;
	<inexact>1.0l - us#0</inexact>;
	<inexact>1.0l * us#0</inexact>;
	<integer>1.0l \ us#0</integer>;
	<inexact>1.0l / us#0</inexact>;
	<inexact>1.0l % us#0</inexact>;
	<inexact>1.0l << i#0</inexact>;
	<inexact>1.0l >> i#0</inexact>;
	<integer>1.0l <<< i#0</integer>;
	<integer>1.0l >>> i#0</integer>;
	<inexact>1.0l + i#0</inexact>;
	<inexact>1.0l - i#0</inexact>;
	<inexact>1.0l * i#0</inexact>;
	<integer>1.0l \ i#0</integer>;
	<inexact>1.0l / i#0</inexact>;
	<inexact>1.0l % i#0</inexact>;
	<inexact>1.0l << ui#0</inexact>;
	<inexact>1.0l >> ui#0</inexact>;
	<integer>1.0l <<< ui#0</integer>;
	<integer>1.0l >>> ui#0</integer>;
	<inexact>1.0l + ui#0</inexact>;
	<inexact>1.0l - ui#0</inexact>;
	<inexact>1.0l * ui#0</inexact>;
	<integer>1.0l \ ui#0</integer>;
	<inexact>1.0l / ui#0</inexact>;
	<inexact>1.0l % ui#0</inexact>;
	<inexact>1.0l << l#0</inexact>;
	<inexact>1.0l >> l#0</inexact>;
	<integer>1.0l <<< l#0</integer>;
	<integer>1.0l >>> l#0</integer>;
	<inexact>1.0l + l#0</inexact>;
	<inexact>1.0l - l#0</inexact>;
	<inexact>1.0l * l#0</inexact>;
	<integer>1.0l \ l#0</integer>;
	<inexact>1.0l / l#0</inexact>;
	<inexact>1.0l % l#0</inexact>;
	<inexact>1.0l << ul#0</inexact>;
	<inexact>1.0l >> ul#0</inexact>;
	<integer>1.0l <<< ul#0</integer>;
	<integer>1.0l >>> ul#0</integer>;
	<inexact>1.0l + ul#0</inexact>;
	<inexact>1.0l - ul#0</inexact>;
	<inexact>1.0l * ul#0</inexact>;
	<integer>1.0l \ ul#0</integer>;
	<inexact>1.0l / ul#0</inexact>;
	<inexact>1.0l % ul#0</inexact>;
	<inexact>1.0l << f#0</inexact>;
	<inexact>1.0l >> f#0</inexact>;
	<integer>1.0l <<< f#0</integer>;
	<integer>1.0l >>> f#0</integer>;
	<inexact>1.0l + f#0</inexact>;
	<inexact>1.0l - f#0</inexact>;
	<inexact>1.0l * f#0</inexact>;
	<integer>1.0l \ f#0</integer>;
	<inexact>1.0l / f#0</inexact>;
	<inexact>1.0l % f#0</inexact>;
	<inexact>1.0l << d#0</inexact>;
	<inexact>1.0l >> d#0</inexact>;
	<integer>1.0l <<< d#0</integer>;
	<integer>1.0l >>> d#0</integer>;
	<inexact>1.0l + d#0</inexact>;
	<inexact>1.0l - d#0</inexact>;
	<inexact>1.0l * d#0</inexact>;
	<integer>1.0l \ d#0</integer>;
	<inexact>1.0l / d#0</inexact>;
	<inexact>1.0l % d#0</inexact>;
	<undef>1.0l << v#0</undef>;
	<undef>1.0l >> v#0</undef>;
	<integer>1.0l <<< v#0</integer>;
	<integer>1.0l >>> v#0</integer>;
	<undef>1.0l + v#0</undef>;
	<undef>1.0l - v#0</undef>;
	<undef>1.0l * v#0</undef>;
	<integer>1.0l \ v#0</integer>;
	<undef>1.0l / v#0</undef>;
	<real>1.0l % v#0</real>;
    }
}"
